# Why Pipekit A control plane for Argo Workflows. Observability, governance, scale, and security on top of what Argo already gives you. Pipekit is the control plane for [Argo Workflows](https://argoproj.github.io/argo-workflows/). Platform teams use it to operate Argo at scale and give their developers a self-serve surface; data and ML teams use it to find, debug, and re-run their pipelines without learning the cluster. Pipekit sits on top of Argo, not in place of it. Your workflows still execute as Argo `Workflows` on your own Kubernetes clusters; Pipekit adds the dashboards, access control, multi-cluster management, log handling, and integrations that teams typically rebuild themselves. Four reasons teams adopt Pipekit: * [**Observability**](/why-pipekit/observability): unified UI across clusters, persisted Run history and logs, log-level detection and search, OpenTelemetry workflow metrics. * [**Governance**](/why-pipekit/governance): workspaces, IdP-backed RBAC, per-environment secrets, default-deny access, audit-quality submission enforcement. * [**Scale**](/why-pipekit/scale): multi-cluster routing, node-status offloading, Vector-based log collection, cross-cluster disaster recovery. * [**Security**](/why-pipekit/security): bring-your-own-cluster architecture, SBOMs and signed containers, optional self-hosted control plane for air-gapped deployments. ## Architecture at a glance ![Pipekit architecture](/files/y1Cbl9j5aMLKWLt954ql) Pipekit deploys a small [agent](/concepts/pipekit-agent) into each Kubernetes cluster alongside Argo Workflows. The agent brokers commands from Pipekit's control plane and reports status, logs, and metrics back. Your workflows, data, and compute stay in your cluster; the control plane is hosted by Pipekit, or you can [self-host](/self-hosting-pipekit) the whole stack. For the two deployment models side by side, see [Pipekit Cloud vs Self-Hosted](/concepts/cloud-vs-self-hosted). To try Pipekit, follow [Get Started > Evaluate Pipekit Cloud](/get-started/evaluate-cloud). It's a 5-minute path from sign-up to a running workflow. # Observability Unified observability for Argo Workflows: runs, logs, and metrics in one place. Argo Workflows runs reliably; finding and debugging individual runs across many namespaces, clusters, and teams is the problem. Pipekit gives every Argo `Workflow` a Pipekit-side [Pipe](/concepts/pipe) and [Run](/concepts/run), aggregates them into one UI, and persists their state and logs beyond the lifetime of the underlying Kubernetes objects. ## What Pipekit observes ### A single UI for every Run, across every cluster Submit from the [CLI](/reference/cli), the UI, a Git event, or a [cron schedule](/concepts/cron-and-externally-triggered). Every Run lands in the same Pipes view. [Externally triggered Workflows](/concepts/cron-and-externally-triggered#externally-triggered-workflows) submitted to your cluster outside Pipekit (via `kubectl`, Argo CLI, or Argo Events) can also be surfaced in Pipekit, so you can migrate to Pipekit without losing visibility into existing pipelines. ### Persisted Run history beyond pod lifecycle Argo deletes completed pods on its own schedule. Pipekit captures Run status, the [workflow node graph](/using-pipekit/runs/run-graph), [pod logs](/using-pipekit/runs/pod-logs), [workflow logs](/using-pipekit/runs/workflow-logs), and the [submitted YAML](/using-pipekit/runs/workflow-yaml) when the Run starts, and keeps them indefinitely. ### Log search with structured-format detection Pipekit auto-detects log levels from common formats (JSON, logfmt, syslog, bracketed, timestamp-prefixed) and color-codes them inline. You can filter by container, search across a Run with regex, and pivot from a failing pod to its workflow node graph in one click. For the full list of supported log formats, see [Pod Logs > Log Level Detection](/using-pipekit/runs/pod-logs#log-level-detection). ### Bring your own logging backend By default Pipekit hosts your logs. If you'd rather keep them in your existing stack, point the [Pipekit Agent](/concepts/pipekit-agent) at your S3 / object storage and Pipekit will read from there. See [BYO Logging Backend](/organizations-and-access/byo-logs). ### OpenTelemetry workflow metrics Pipekit collects OpenTelemetry workflow metrics from each registered [Cluster](/concepts/cluster) and surfaces them as dashboards. You see queue depth, scheduling latency, success and failure rates, and pod resource use per Pipe, without instrumenting your workflows. See [Metrics & Alerts](/using-pipekit/metrics-and-alerts). # Governance Workspaces, IdP-backed RBAC, audit-quality access enforcement. Argo Workflows ships with Kubernetes-native RBAC. That works for small teams; it scales poorly when many teams share clusters, when access changes weekly, and when an auditor wants to know who submitted what. Pipekit adds an access layer above Argo that maps cleanly to how organizations already manage identity. ## How Pipekit enforces governance ### Workspaces bind `{cluster, namespace}` pairs to teams A [workspace](/concepts/access-control#workspaces) is a named scope that contains one or more `{cluster, namespace}` pairs. Every Pipe, Run, and Template belongs to exactly one workspace. Each `{cluster, namespace}` pair belongs to one workspace, so workspaces are non-overlapping and you can't accidentally double-bind a namespace. This lets you carve a single cluster into team-shaped slices without giving every team cluster-admin rights. ### IdP-backed roles, not local users Pipekit integrates with [Okta](/organizations-and-access/sso/okta) and [Microsoft Entra](/organizations-and-access/sso/entra). Once SSO is configured, password login is disabled for your domain. Users authenticate exclusively through your IdP, and access is determined by their IdP group membership. Group membership changes propagate automatically: remove a user from your IdP and they lose Pipekit access immediately. No accounts to deprovision, no orphan logins. ### Five roles, two binding scopes Pipekit ships with five roles (Org Admin, Workspace Admin, Editor, Runner, Viewer), bound at either org scope (applies to every workspace) or workspace scope (one workspace). When a user holds bindings at both scopes, the higher-privilege role applies. See the full [permission reference](/concepts/access-control#permission-reference) for the exact action set per role. ### Default-deny, enforced at submission No access is granted implicitly. Namespaces added to a cluster are inaccessible until an Org Admin binds them to a workspace. Submission is validated at the Pipekit API layer. When a Workflow is submitted via UI, CLI, or [Python SDK](/reference/python-sdk), Pipekit checks the authenticated user's bindings cover the target cluster and namespace. If not, the submission is rejected before reaching Argo. ### Per-environment secrets Secrets are scoped per workspace and per environment. A Pipe in `team-data-prod` can reference different secret values than the same Pipe definition would resolve to in `team-data-dev`, without forking the workflow YAML. See [Pipes > Edit > Secrets](/using-pipekit/pipes/edit/secrets). ### Audit trail by design Every submission carries an authenticated user identity. Pipekit doesn't modify the workflow spec. It validates access and either allows or rejects, so your existing Argo audit and admission controls remain in place underneath. ## See it in practice The [Infrastructure as Code with OpenTofu](/use-cases/infrastructure-as-code) use case shows the governance model in action: per-team workspaces, mutual-exclusion guarantees on the `tofu plan` step, and a separately-scoped `apply` Template that only authorized users can submit. # Scale Multi-cluster routing, log scale-out, node-status offloading, cross-cluster failover. Argo Workflows scales fine inside one cluster until you hit one of the usual ceilings: the `etcd` size limit for large workflow statuses, log volume that overwhelms in-cluster storage, or the operational cost of running many independent Argo deployments side by side. Pipekit handles the multi-cluster shape and the in-cluster ceilings so platform teams stop building these in-house. ## How Pipekit scales Argo Workflows ### Multi-cluster from day one Register as many [Clusters](/concepts/cluster) as you want with one Pipekit Organization. The [Pipekit Agent](/concepts/pipekit-agent) runs in each cluster and reports back to a single control plane, so your Pipes, Runs, and Templates are visible across clusters from one UI. ### Cluster-side queue management Pipekit lets you set per-cluster workflow priorities and queue caps from the UI. This is useful when you want a `dev` cluster to back off during a `prod` traffic spike. See [Clusters > Queuing](/using-pipekit/clusters#queuing). ### Vector-based log collection In-cluster log capture works for small workflows; at high volume, Argo's wait-container log path drops lines and overwhelms the API server. Pipekit's Vector integration intercepts logs at the node level and ships them to your storage of choice (S3, GCS, etc.) before they reach the wait container. See [Operating at Scale > Vector Log Collection](/using-pipekit/operating-at-scale/vector-log-collection). ### Node status offloading Argo stores each Workflow's full node status inside the `Workflow` resource in `etcd`. Workflows with many nodes (large fan-outs, deep DAGs) eventually exceed `etcd`'s 1 MB object size and fail to update. Pipekit's [node status offloading](/using-pipekit/operating-at-scale/node-status-offloading) moves the status off `etcd` into an external store so very large workflows stop hitting the ceiling. ### Cross-cluster disaster recovery If a cluster goes down, you can fail Pipes over to another registered Cluster without rewriting Pipe definitions. The DR runbook covers the toggle, the data-plane considerations, and the rollback path. See [Clusters > Disaster Recovery](/using-pipekit/clusters/disaster-recovery). ### Templates that propagate across clusters A [Template](/concepts/templates) lives in Git and Pipekit propagates it to every cluster it's registered on. You define the workflow component once and have it usable from any Pipe on any cluster, without copying YAML between clusters. ## See it in practice The [Infrastructure as Code with OpenTofu](/use-cases/infrastructure-as-code) use case demonstrates this shape across three Terraform paths in parallel, with mutual exclusion at the engine level and an `apply` Template that propagates across environments. # Security Bring-your-own-cluster architecture, SBOMs, signed containers, optional air-gapped deployment. Pipekit is built so your workflow data, secrets, and compute stay in your infrastructure. The control plane brokers commands and metadata; the actual `Workflow` execution and your data never leave the cluster. ## How Pipekit secures the stack ### Bring-your-own-cluster architecture The [Pipekit Agent](/concepts/pipekit-agent) runs in your Kubernetes cluster and connects outbound to Pipekit's control plane (or to your self-hosted control plane). Your workflows execute on your nodes, against your storage, using your service accounts and your secrets. Pipekit never has direct cluster credentials or inbound network access into your environment. ### Optional self-hosted, air-gapped control plane If a hosted control plane is incompatible with your compliance posture, [Self-Hosted Pipekit](/self-hosting-pipekit) installs the entire stack (UI, API, database, agent) inside your own infrastructure. The install is designed to work in air-gapped environments; see [Container Images](/self-hosting-pipekit/dependencies/container-images) for the image inventory. ### IdP-backed access, default-deny Authentication is delegated to your identity provider via [SSO](/organizations-and-access/sso). Authorization is default-deny. Namespaces added to a cluster are inaccessible until an Org Admin explicitly binds them to a workspace. For the full model, see [Governance](/why-pipekit/governance) and [Access Control](/concepts/access-control). ### Software Bill of Materials (SBOM) #### Containers An SBOM for our public containers (e.g. [Pipekit Agent](/concepts/pipekit-agent) and the [Pipekit CLI](/reference/cli#docker-container)) is embedded within the container image in SPDX format. You can extract the SBOM by running the following `docker buildx` command: ```bash docker buildx imagetools inspect pipekit13/pipekit-agent:v0.0.0 --format '{{ json (index .SBOM "linux/amd64").SPDX}}' > pipekit-agent.spdx ``` Remember to set the image tag accordingly: * [Pipekit Agent](https://hub.docker.com/r/pipekit13/pipekit-agent/tags) * [Pipekit CLI](https://hub.docker.com/r/pipekit13/cli/tags) We combine a `linux/amd64` and a `linux/arm64` variant of the containers as one image tag, so you need to choose the correct variant of the SBOM to extract. Alternatively, you can extract a list of all the packages used in the container by running: ```bash docker buildx imagetools inspect pipekit13/pipekit-agent:v0.0.0 --format '{{ range (index .SBOM "linux/amd64").SPDX.packages }}{{ println .name .versionInfo }}{{ end }}' | sort ``` You can also search for individual packages: ```bash docker buildx imagetools inspect pipekit13/pipekit-agent:v0.0.0 --format '{{ range (index .SBOM "linux/amd64").SPDX.packages }}{{ if eq .name "busybox" }}{{ println .versionInfo }}{{ end }}{{ end }}' ``` #### CLI Binaries SBOM files are available alongside the CLI binaries in the [Pipekit CLI repository](https://github.com/pipekit/cli/releases). ### Signed containers We sign our public containers using [Cosign](https://docs.sigstore.dev/cosign/installation). Signing materials are stored in a tamper-resistant public log. After installing Cosign, verify the signature of a container by running: ```bash cat < pipekit-cosign.pub -----BEGIN PUBLIC KEY----- MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEUsGMXv9tynS/2yu4WkZLZwLYIbq1 kI/iAtFVazXjKbZVS4+UJnAFt1eh6I8+MEN75KHUD+xw0rm918ZxgRlXKA== -----END PUBLIC KEY----- EOF cosign verify --key pipekit-cosign.pub pipekit13/pipekit-agent:latest ``` You can use an admission controller such as [Connaisseur](https://github.com/sse-secure-systems/connaisseur) to verify the signature of the container at runtime within Kubernetes. # Get Started Get started with Pipekit in 5 to 10 minutes. Pick the path that matches what you're trying to do. * [Evaluate Pipekit Cloud](/get-started/evaluate-cloud): 5 min. Sign up, get a free-trial cluster, run a sample Pipe. Best for evaluators. * [Operate Pipekit](/get-started/operate): 10 min. Install the Pipekit Agent into your own Kubernetes cluster, connect it to Pipekit, and verify with a sample Pipe. Best for platform engineers setting Pipekit up for a team. * [Author Workflows](/get-started/author): 5 min. Install the CLI and submit your first workflow against a cluster someone else has already connected. Best for workflow authors joining an existing Pipekit Organization. Each path is a single linear happy path. Once you're done, the rest of the docs (especially [Using Pipekit](/using-pipekit) and [Concepts](/concepts)) covers depth and edge cases. If you'd rather run Pipekit entirely on your own infrastructure (air-gapped, self-hosted control plane), start at [Self-Hosting Pipekit > Evaluate Self-Hosted](/self-hosting-pipekit/evaluate) instead. # Evaluate Pipekit Cloud Sign up for Pipekit Cloud, get a free-trial cluster, and run your first workflow in 5 minutes. A linear 5-minute path from "I want to try Pipekit" to "my first workflow is running." This quickstart uses the **free-trial cluster** Pipekit provisions for new accounts. If you'd rather use your own cluster, follow [Operate Pipekit](/get-started/operate) instead. ## Prerequisites * A computer running macOS, Linux, or Windows (for the CLI). * A browser (for the UI). ## 1. Create an account 1. Go to and click `Get started free`. 2. Complete the signup form, or use SSO. 3. Check your email for the welcome message and click the confirmation link. 4. Log in. ## 2. Create an Organization Pipekit will take you to the `Org` page on first login. 1. Click `Create an Org`. 2. Give the [Organization](/concepts/organization) a name and description. 3. Click `Submit`. ## 3. Provision the free-trial cluster When prompted to connect a cluster, confirm that you want a Pipekit-hosted free-trial cluster. Provisioning takes 2 to 3 minutes; you'll be redirected to the Pipes page when it's ready. The free-trial cluster comes pre-configured with Argo Workflows, the [Pipekit Agent](/concepts/pipekit-agent), and a working MinIO artifact store. For its limits and configuration, see [Free Trial Cluster](/get-started/free-trial-cluster). ## 4. Install the CLI ```bash # macOS / Linux (Homebrew) brew install pipekit/tap/cli # Windows (Scoop) scoop bucket add pipekit https://github.com/pipekit/scoop.git scoop install pipekit/cli ``` For other install methods (NixOS, Docker), see [Reference > CLI > Install](/reference/cli#installation). ## 5. Log in from the CLI ```bash pipekit login ``` Follow the prompts to authenticate against the same account you created in step 1. ## 6. Submit your first workflow Use the [Pipekit Examples](https://github.com/pipekit/examples) repository for a tested sample workflow: ```bash git clone https://github.com/pipekit/examples.git cd examples pipekit submit --cluster-name= examples/dag-diamond/workflow.yaml ``` Pipekit creates a [Pipe](/concepts/pipe) named after the workflow's `generateName` and submits a [Run](/concepts/run). The CLI prints a link to the Run in the UI. ## 7. View the Run Open the link from step 6 (or go to ). You'll see: * The [Run Graph](/using-pipekit/runs/run-graph): a DAG view of the workflow's tasks. * [Pod Logs](/using-pipekit/runs/pod-logs) per container, with level detection and search. * The [submitted YAML](/using-pipekit/runs/workflow-yaml). ## What's next * **Trigger Workflows from Git** instead of the CLI: [Pipes](/using-pipekit/pipes) covers GitHub, GitLab, and Bitbucket integration. * **Schedule Workflows**: see [Cron](/using-pipekit/pipes/cron). * **Author with Python**: see [Reference > Python SDK](/reference/python-sdk) (works with [Hera](https://github.com/argoproj-labs/hera)). * **Add your own cluster** alongside the free trial: [Operate Pipekit](/get-started/operate). * **Set up access control** before inviting teammates: [Access Control](/concepts/access-control). ## Best practice Set a `namespace` and `serviceAccountName` on your workflows. The [Pipekit Examples](https://github.com/pipekit/examples) workflows use `namespace: argo` and `serviceAccountName: argo-workflow`, which match the free-trial cluster's configuration. If you submit a workflow without these set, Pipekit submits to `default` and your workflow will likely fail with permission errors. # Operate Pipekit Install the Pipekit Agent into your own Kubernetes cluster and connect it to Pipekit Cloud in 10 minutes. A 10-minute path from "I have a Kubernetes cluster with Argo Workflows" to "Pipekit is managing it." This quickstart assumes you're connecting your own cluster to **Pipekit Cloud**. For a fully self-hosted control plane (no Pipekit Cloud connection), see [Self-Hosting Pipekit > Evaluate Self-Hosted](/self-hosting-pipekit/evaluate) instead. ## Prerequisites * A Kubernetes cluster with [Argo Workflows installed](https://argo-workflows.readthedocs.io/en/stable/installation/#production-installation). * `kubectl` configured against that cluster. * `helm` (v3) installed locally. * A Pipekit Cloud account. If you don't have one, follow [Evaluate Pipekit Cloud](/get-started/evaluate-cloud) steps 1 to 2, then come back. ## 1. Create the Cluster in Pipekit 1. Log in to . 2. Decline the offer for a Pipekit-hosted free-trial cluster. 3. Click `Connect A Cluster`. 4. Select the [Organization](/concepts/organization) the cluster will belong to. 5. Give the [Cluster](/concepts/cluster) a name (lowercase, no whitespace) and a description. 6. Click `Submit`. Pipekit generates the install command and Helm values for your cluster. ## 2. Install the Pipekit Agent Pipekit's UI prints a Helm install command of the form: ```bash helm upgrade pipekit-agent oci://registry.pipekit.io/charts/pipekit-agent \ --install \ --namespace=argo \ --set secrets.pipekitSecretAccessKey="" \ --set secrets.pipekitClusterId="" ``` Run that command against your cluster. For the full chart values and configuration options, see [Reference > Helm Chart Values > Agent](/reference/helm-values/agent). ## 3. Verify the agent is connected ```bash kubectl get pods -n argo -l app=pipekit-agent ``` You should see a Pipekit Agent pod in `Running` state within a minute. The Pipekit UI's Cluster page also flips from `Connecting` to `Active`. ## 4. Submit a sample workflow ```bash brew install pipekit/tap/cli # or see other install methods in Reference > CLI pipekit login git clone https://github.com/pipekit/examples.git cd examples pipekit submit --cluster-name= examples/dag-diamond/workflow.yaml ``` The CLI prints a link to the [Run](/concepts/run) in the Pipekit UI. Open it to see the [Run Graph](/using-pipekit/runs/run-graph), [Pod Logs](/using-pipekit/runs/pod-logs), and the submitted workflow YAML. ## What's next * **Configure SSO and access control** before inviting teammates: [Access Control](/concepts/access-control), [SSO setup](/organizations-and-access/sso). * **Connect a Git provider** so Workflows trigger on commits and pull requests: [Pipes](/using-pipekit/pipes). * **Set up alerts** for workflow failures: [Alert Providers](/organizations-and-access/alert-providers). * **Scale your cluster** beyond the defaults: [Operating at Scale](/using-pipekit/operating-at-scale). ## If something goes wrong The Pipekit Agent logs are your first stop: ```bash kubectl logs -n argo -l app=pipekit-agent --tail=200 ``` If the agent reports an auth or registration error, double-check the secret values from step 2. If it's reaching Pipekit but the Cluster still shows `Connecting` in the UI, check that the `pipekitClusterId` matches the Cluster you created in step 1. # Author Workflows Install the Pipekit CLI and submit your first workflow against a connected cluster. A 5-minute path for workflow authors joining a Pipekit Organization that's already set up. If you don't have a Pipekit account yet, follow [Evaluate Pipekit Cloud](/get-started/evaluate-cloud) instead. If you're the platform engineer setting Pipekit up for a team, follow [Operate Pipekit](/get-started/operate). ## Prerequisites * A Pipekit account in an existing Organization, invited by an Org Admin. * The name of a [Cluster](/concepts/cluster) you have access to (ask your admin). * A computer running macOS, Linux, or Windows. ## 1. Install the CLI ```bash # macOS / Linux (Homebrew) brew install pipekit/tap/cli # Windows (Scoop) scoop bucket add pipekit https://github.com/pipekit/scoop.git scoop install pipekit/cli ``` For NixOS, Docker, and binary downloads, see [Reference > CLI > Install](/reference/cli#installation). ## 2. Log in ```bash pipekit login ``` If your Organization has [SSO](/organizations-and-access/sso) configured, the CLI redirects you to your identity provider. Otherwise enter your Pipekit username and password. The CLI stores your access token at `~/.pipekit/token`. ## 3. List the clusters you can submit to ```bash pipekit list clusters ``` This confirms which clusters your account has access to. Note the `CLUSTER NAME` you'll use in the next step. ## 4. Submit a workflow Clone the Pipekit Examples repo and submit a sample workflow: ```bash git clone https://github.com/pipekit/examples.git cd examples pipekit submit --cluster-name= examples/dag-diamond/workflow.yaml ``` The CLI prints a link to the [Run](/concepts/run) in the Pipekit UI. ## 5. View the Run Open the link from step 4 (or browse to ). You'll see: * The [Run Graph](/using-pipekit/runs/run-graph): DAG view of the workflow's tasks. * [Pod Logs](/using-pipekit/runs/pod-logs) per container. * The [submitted YAML](/using-pipekit/runs/workflow-yaml). * Status, duration, and triggering metadata. ## What's next * **Submit your own workflows**: point `pipekit submit` at any Argo `Workflow` YAML. * **Stop, terminate, or restart Runs**: see [CLI > Run Actions](/reference/cli#run-actions) or do it from the UI. * **Submit from Python with Hera**: see [Reference > Python SDK](/reference/python-sdk). * **Author CronWorkflows**: see [Cron](/using-pipekit/pipes/cron). * **Use an AI agent** to debug failed Runs or author new workflows. See [AI](/ai). ## Best practice Set `namespace` and `serviceAccountName` on every workflow you submit. If you omit them, Pipekit submits to the cluster's `default` namespace and `default` service account, which usually lack the permissions Argo needs. Ask your platform engineer what namespace and service account your team is supposed to use. # Free Trial Cluster During your free trial period, we can provide you with a free cluster to use. If you wish to start a free trial, follow the [Getting Started Guide](/get-started/evaluate-cloud). You are welcome to provide your own cluster to use during the free trial period, or even combine your own cluster with the free trial cluster in order to try out the multi-cluster capabilities of Pipekit. ## Cluster Details ### Installed Software In order to facilitate your trial of Pipekit, the free trial cluster comes with a number of software packages pre-installed and pre-configured. These include: * Argo Workflows * Minio (s3-compatible object storage) * Pipekit Agent ### Software Versions The free trial clusters are constantly maintained, meaning that software versions can change frequently. We aim to keep the cluster and its contents on the latest stable versions. If you wish to know the exact versions of software installed in the cluster at a given time, you can run the [get-versions](https://github.com/pipekit/examples/tree/main/examples/get-versions) example from the Pipekit Examples repository. ### Cluster Security Your provisioned cluster is not shared with any other users. Your free trial organization will be the only organization with access to the cluster. Access to the cluster is restricted to the Pipekit team and your organization's users. However, we recommend you do not use the cluster for any sensitive data or workflows. We recommend you fork our [Pipekit Examples Github repository](https://github.com/pipekit/examples) and use the workflows therein. You have no access the cluster itself. You can trigger Pipekit workflows and the Pipekit Agent will execute them on your behalf inside the cluster. ### Cluster Availability While we will make every effort to ensure you have a smooth free trial, we make no guarantees as to the availability of the free trial cluster. ### Namespace Your workflows should be executed in the `argo` namespace. ### Service Account You should use the `argo-workflow` Service Account Name to run your workflows. ## Docker Registry Credentials (imagePullSecrets) To use private container registries, or to avoid rate limits from public registries. We recommend you [add your docker registry credentials to your org in pipekit](/organizations-and-access/settings#docker-registry-credentials-imagepullsecrets). Any workflows run from Pipekit will then automatically inherit these secrets. ## Cluster Limitations The cluster is intended for trial purposes only. As such, there are a number of limitations in place to ensure the cluster is not abused. ### Resource Limits The cluster is limited in CPU, Memory and Ephemeral Storage. If you breach this limit, the workflows will fail or time out. The limits cannot be increased. You cannot use persistent storage in the cluster. In order to facilitate Kubernetes scheduling, if you do not set a resource limit on a resource, we set a default limit of 200m CPU, 200Mi Memory and 100Mi Ephemeral Storage. You can override this by setting a limit in your resource requests in your Workflows. If you see an error similar to `Invalid value: "1Gi": must be less than or equal to memory limit of 200Mi`, this indicates that you set a memory resource request above the default limit, but you did not set a higher memory resource limit. In this case you should set a memory limit on the resource that matches or exceeds your memory request. The workflow examples contained in our [Pipekit Examples Github repository](https://github.com/pipekit/examples) will all work within the resource limits of the free trial cluster. ### Minio Argo Workflows is configured to use minio as an artifactRepository. The minio endpoint can be reached at `http://minio.pipekit.svc.cluster.local:9000`. The minio access key and secret key are `pipekit` and `sup3rs3cr3tp4ssw0rd1` respectively. Minio does not have persistent storage. All artifacts are stored in memory and may be lost at any time. You should not rely on minio for long-term storage of artifacts. It is recommended to keep the total size of artifacts below 1GB. ### Argo Workflows Argo Workflows is pre-configured with the following [workflowDefaults](https://argoproj.github.io/argo-workflows/default-workflow-specs/): ```yaml workflowDefaults: spec: activeDeadlineSeconds: 3600 artifactGC: serviceAccountName: argo-workflow strategy: OnWorkflowCompletion podGC: strategy: OnPodSuccess ttlStrategy: secondsAfterCompletion: 120 volumeClaimGC: strategy: OnWorkflowCompletion ``` These cannot be changed in the free trial cluster, however you can overwrite them in each individual workflow. ## Deleting the Free Trial Cluster If you no longer wish to use the free trial cluster, you can delete it by navigating to the cluster settings menu and deleting it as [documented here](/using-pipekit/clusters#modifying-a-cluster). Once a free trial cluster has been deleted, it cannot be recreated. # Use Cases Concrete examples of what teams build with Pipekit and Argo Workflows. The pages in this section walk through what teams actually build with Pipekit and Argo Workflows. Each one is a single page: narrative framing for prospects up top, full technical walkthrough (YAML, DAGs, best practices) below. * [Infrastructure as Code with OpenTofu](/use-cases/infrastructure-as-code): PR-time `tofu plan` review, nightly drift detection, and the safety patterns to apply before `tofu apply` ever runs. # Infrastructure as Code with OpenTofu Use Pipekit and Argo Workflows to validate, plan, and apply infrastructure-as-code changes through your existing review pipeline. ## The problem OpenTofu and Terraform changes are high-blast-radius. A misconfigured security group or an unintended `tofu destroy` can take down production faster than almost any other class of change in a typical platform. The standard mitigations (security scanning, linting, `tofu plan` review, drift detection) are well understood, but stitching them together is not. Most teams end up running `tofu plan` inside a generic CI runner (GitHub Actions, Jenkins, GitLab CI) and pasting the output into pull-request comments. That works for a single team and a single environment. It breaks down quickly: the plan output is hard to review at scale, the runner doesn't enforce mutual exclusion so two engineers can race each other into a locked state, nightly drift detection has nowhere natural to live, and the `apply` step turns into "whoever has the credentials on their laptop." The teams that get this right tend to converge on the same shape: a real DAG, a real workflow engine, secrets the runner doesn't touch, mutual exclusion enforced at the engine level, and a separate path for `plan` vs `apply`. That shape is exactly what Argo Workflows gives you. ## How Pipekit helps Argo Workflows runs the DAG. Pipekit adds the surfaces an Argo deployment by itself doesn't have: a unified UI across [Clusters](/concepts/cluster), persisted [Run](/concepts/run) history with searchable [logs](/using-pipekit/runs/pod-logs), per-environment [secrets](/using-pipekit/pipes/edit/secrets) scoped to [workspaces](/concepts/access-control#workspaces), [Templates](/concepts/templates) that let you share the `apply` step safely across teams, and [alerting](/using-pipekit/pipes/edit/alerting) when drift detection fires. The two worked examples below come from a real Pipekit customer's setup. The first is a pull-request validation Workflow that runs `checkov`, `tflint`, and `tofu plan` against three Terraform paths in parallel and posts the plan output as a PR comment. The second is a CronWorkflow that runs `tofu plan -detailed-exitcode` nightly to detect drift. Both are designed so the `apply` step is intentionally separate. See the [Best practices](#best-practices) section. ## Worked example: Pull-request validation When a pull request modifies infrastructure code, an automated Workflow validates the changes before merge. The Workflow performs several validation steps: 1. Clone the infrastructure repository. 2. Run security scans to detect misconfigurations (`checkov`). 3. Run linting to enforce best practices (`tflint`). 4. Generate Terraform/OpenTofu plans showing what will change. 5. Post plan summaries as PR comments for review. ### Workflow Structure The PR validation Workflow consists of multiple tasks organized as a DAG (directed acyclic graph): ```yaml - name: main dag: tasks: - name: clone-repo template: clone-repo - name: checkov-scan template: checkov-scan depends: clone-repo - name: tflint template: tflint depends: clone-repo - name: tfplan template: tfplan depends: tflint - name: tfplan-to-comment template: tfplan-to-comment depends: tfplan ```
View complete PR validation workflow ````yaml apiVersion: argoproj.io/v1alpha1 kind: Workflow metadata: generateName: tf-pr- namespace: ci spec: serviceAccountName: ci entrypoint: main synchronization: mutexes: - name: tf volumeClaimTemplates: - metadata: name: workdir spec: accessModes: [ "ReadWriteMany" ] storageClassName: nfs resources: requests: storage: 1Gi templates: - name: main dag: tasks: - name: clone-repo template: clone-repo - name: get-pr template: get-pr - name: checkov-scan template: checkov-scan arguments: parameters: - name: path value: "{{item}}" withItems: [ terraform, terraform/region-1, terraform/region-2 ] depends: clone-repo - name: tflint template: tflint arguments: parameters: - name: path value: "{{item}}" withItems: [ terraform, terraform/region-1, terraform/region-2 ] depends: clone-repo - name: tfplan template: tfplan arguments: parameters: - name: path value: "{{item}}" withItems: [ terraform, terraform/region-1, terraform/region-2 ] depends: tflint - name: tfplan-to-comment template: tfplan-to-comment arguments: parameters: - name: pr_num value: "{{tasks.get-pr.outputs.parameters.pr_num}}" - name: index value: "{{item}}" withItems: [ terraform, terraform/region-1, terraform/region-2 ] depends: (tfplan && get-pr) - name: clone-repo container: image: alpine command: - sh - -c - | apk --update add openssh-client git eval `ssh-agent -s` mkdir -p /workdir/src/github.com/; cd /workdir/src/github.com/; ssh-add /root/.ssh/ssh-deploy-key; ssh-keyscan github.com > /root/.ssh/known_hosts; git config --global --add safe.directory '*'; git clone git@github.com:/.git; cd ; git checkout $GIT_COMMIT; volumeMounts: - name: workdir mountPath: /workdir - name: checkov-scan inputs: parameters: - name: path container: image: /terraform command: - bash - -c - | mkdir -p /checkov-scan cp -R /workdir/src/github.com// /checkov-scan cd /checkov-scan//{{inputs.parameters.path}}/ tofu init checkov --quiet --compact --directory . --repo-root-for-plan-enrichment . env: - name: AWS_ACCESS_KEY_ID valueFrom: secretKeyRef: name: key: aws-access-key-id - name: AWS_SECRET_ACCESS_KEY valueFrom: secretKeyRef: name: key: aws-secret-access-key volumeMounts: - name: workdir mountPath: /workdir - name: tflint inputs: parameters: - name: path container: image: /terraform command: - bash - -c - | mkdir -p /tflint-dir cp -R /workdir/src/github.com// /tflint-dir cd /tflint-dir//{{inputs.parameters.path}}/ tofu init tflint --init --no-color tflint --no-color env: - name: AWS_ACCESS_KEY_ID valueFrom: secretKeyRef: name: key: aws-access-key-id - name: AWS_SECRET_ACCESS_KEY valueFrom: secretKeyRef: name: key: aws-secret-access-key volumeMounts: - name: workdir mountPath: /workdir - name: tfplan inputs: parameters: - name: path container: image: /terraform command: - bash - -c - | mkdir -p /tfplan-dir mkdir -p /workdir/terraform cp -R /workdir/src/github.com// /tfplan-dir cd /tfplan-dir//{{inputs.parameters.path}}/ tofu init tofu plan -lock-timeout=600s -out=tfplan tofu show -json tfplan | tf-summarize > /workdir/{{inputs.parameters.path}}-plan.txt tofu show tfplan tf-summarize tfplan env: - name: AWS_ACCESS_KEY_ID valueFrom: secretKeyRef: name: key: aws-access-key-id - name: AWS_SECRET_ACCESS_KEY valueFrom: secretKeyRef: name: key: aws-secret-access-key volumeMounts: - name: workdir mountPath: /workdir - name: tfplan-to-comment inputs: parameters: - name: pr_num - name: index container: image: cloudposse/github-commenter:0.16.2 env: - name: GITHUB_TOKEN valueFrom: secretKeyRef: name: key: github-token - name: GITHUB_COMMENT_FORMAT value: | Tofu plan ({{inputs.parameters.index}}): ``` {{.}} ``` command: - /bin/sh - -c - | if [ "${isPR}" == "true" ] then cat /workdir/{{inputs.parameters.index}}-plan.txt | github-commenter fi volumeMounts: - name: workdir mountPath: /workdir ````
### Security scanning The Workflow uses Checkov to scan infrastructure code for security and compliance issues: ```yaml - name: checkov-scan container: image: /terraform command: - bash - -c - | cd /workdir/terraform/ tofu init checkov --quiet --compact --directory . --repo-root-for-plan-enrichment . ``` ### Terraform planning The Workflow generates a plan showing what infrastructure changes would occur: ```yaml - name: tfplan container: image: /terraform command: - bash - -c - | cd /workdir/terraform/ tofu init tofu plan -lock-timeout=600s -out=tfplan tofu show -json tfplan | tf-summarize > /workdir/plan.txt tofu show tfplan ``` The plan output is captured and posted as a comment on the pull request, giving reviewers clear visibility into the proposed changes. ## Worked example: Nightly drift detection Infrastructure drift occurs when the actual state of your infrastructure diverges from what is defined in your code. A scheduled [CronWorkflow](/concepts/cron-and-externally-triggered) can detect this drift by running `tofu plan` regularly and alerting when changes are detected. ### CronWorkflow structure The nightly drift detection Workflow runs on a schedule and checks for infrastructure changes: ```yaml spec: schedules: - "0 13 * * 1-5" timezone: "UTC" workflowSpec: entrypoint: main templates: - name: main dag: tasks: - name: clone-repo template: clone-repo - name: check-and-notify template: check-and-notify depends: clone-repo ```
View complete nightly drift detection workflow ```yaml apiVersion: argoproj.io/v1alpha1 kind: CronWorkflow metadata: name: tf-nightly namespace: ci labels: cron: "true" spec: successfulJobsHistoryLimit: 1 failedJobsHistoryLimit: 1 schedules: - "0 13 * * 1-5" timezone: "UTC" startingDeadlineSeconds: 0 suspend: false workflowSpec: entrypoint: main synchronization: mutexes: - name: tf serviceAccountName: ci volumeClaimTemplates: - metadata: name: workdir spec: accessModes: [ "ReadWriteMany" ] storageClassName: nfs resources: requests: storage: 1Gi templates: - name: main dag: tasks: - name: clone-repo template: clone-repo - name: check-and-notify template: check-and-notify arguments: parameters: - name: path value: "{{item}}" withItems: [ terraform, terraform/region-1, terraform/region-2 ] depends: clone-repo - name: check-and-notify inputs: parameters: - name: path dag: tasks: - name: tfplan template: tfplan arguments: parameters: - name: path value: "{{inputs.parameters.path}}" - name: send-notification template: send-notification arguments: parameters: - name: title value: "Infrastructure drift detected" - name: message value: "Infrastructure has diverged from Terraform code in /{{inputs.parameters.path}}." - name: exitcode value: "{{tasks.tfplan.outputs.parameters.exitcode}}" - name: path value: "{{inputs.parameters.path}}" depends: tfplan - name: clone-repo container: image: alpine command: - sh - -c - | apk --update add openssh-client git eval `ssh-agent -s` mkdir -p /workdir/src/github.com/; cd /workdir/src/github.com/; ssh-add /root/.ssh/ssh-deploy-key; ssh-keyscan github.com > /root/.ssh/known_hosts; git config --global --add safe.directory '*'; git clone git@github.com:/.git; cd ; git checkout $GIT_COMMIT; volumeMounts: - name: workdir mountPath: /workdir - name: tfplan inputs: parameters: - name: path container: image: /terraform command: - bash - -c - | mkdir -p /tfplan-dir cp -R /workdir/src/github.com// /tfplan-dir cd /tfplan-dir//{{inputs.parameters.path}}/ tofu init tofu plan -detailed-exitcode -lock-timeout=600s if [ $? -eq 2 ]; then echo "Tofu apply needed" echo "0" > /tmp/exitcode exit 0 else echo "Infrastructure matches code" echo "1" > /tmp/exitcode exit 0 fi env: - name: AWS_ACCESS_KEY_ID valueFrom: secretKeyRef: name: key: aws-access-key-id - name: AWS_SECRET_ACCESS_KEY valueFrom: secretKeyRef: name: key: aws-secret-access-key volumeMounts: - name: workdir mountPath: /workdir outputs: parameters: - name: exitcode valueFrom: path: /tmp/exitcode - name: send-notification inputs: parameters: - name: title - name: message - name: exitcode - name: path container: image: alpine command: - sh - -c - | if [ "{{inputs.parameters.exitcode}}" == "0" ] then A="{{inputs.parameters.title}}" B="{{inputs.parameters.message}}" AINPUT="${A}\n${B}" # Send notification via your preferred method (Slack, email, etc.) echo "$AINPUT" # Example: curl to Slack webhook, PagerDuty, etc. # curl -H "Content-type: application/json" -X POST -d "$data" ${WEBHOOK_URL} fi env: - name: WEBHOOK_URL valueFrom: secretKeyRef: name: key: webhook-url ```
### Drift detection logic The Workflow runs `tofu plan` with the `-detailed-exitcode` flag, which returns exit code 2 when changes are detected: ```yaml - name: tfplan container: image: /terraform command: - bash - -c - | cd /workdir/terraform/ tofu init tofu plan -detailed-exitcode -lock-timeout=600s if [ $? -eq 2 ]; then echo "Infrastructure drift detected" echo "0" > /tmp/exitcode else echo "Infrastructure matches code" echo "1" > /tmp/exitcode fi ``` When drift is detected, the Workflow sends a notification to alert the team. ## Best practices ### Use mutual exclusion Infrastructure operations should not run concurrently on the same resources. Use Argo's `synchronization.mutexes` to ensure only one Workflow modifies infrastructure at a time: ```yaml spec: synchronization: mutexes: - name: tf ``` ### Secure credentials management Store sensitive credentials in Kubernetes Secrets and inject them into Workflow pods as environment variables: ```yaml env: - name: AWS_ACCESS_KEY_ID valueFrom: secretKeyRef: name: key: aws-access-key-id - name: AWS_SECRET_ACCESS_KEY valueFrom: secretKeyRef: name: key: aws-secret-access-key ``` For tighter integration, use external secrets management solutions like HashiCorp Vault, AWS Secrets Manager, or Azure Key Vault with the appropriate Kubernetes integrations. ### Separate plan from apply Never automatically run `terraform apply` or `tofu apply` in automated Workflows. Always generate plans for review, then apply changes manually or with explicit human approval. A common pattern is to create a [Workflow Template](/using-pipekit/templates) for the apply step. This lets authorized users submit the template to apply infrastructure changes without configuring their local environment with the correct credentials and tooling. The template carries the necessary credentials, container image, and configuration, giving you consistent and secure infrastructure deployments. For example, create a template that takes the plan output as input and applies it: ```yaml apiVersion: argoproj.io/v1alpha1 kind: WorkflowTemplate metadata: name: terraform-apply spec: entrypoint: apply templates: - name: apply inputs: parameters: - name: terraform-path container: image: /terraform command: - bash - -c - | cd /workdir/{{inputs.parameters.terraform-path}}/ tofu apply -auto-approve env: - name: AWS_ACCESS_KEY_ID valueFrom: secretKeyRef: name: key: aws-access-key-id - name: AWS_SECRET_ACCESS_KEY valueFrom: secretKeyRef: name: key: aws-secret-access-key ``` Users submit this template from Pipekit when they're ready to apply reviewed changes. ### Monitor for drift Run drift detection Workflows on a regular schedule (e.g. nightly) to catch unexpected infrastructure changes early. Alert your team when drift is detected so they can investigate and remediate. ### Use node selectors For resource-intensive operations like security scanning, specify node selectors so Workflows run on appropriate hardware: ```yaml nodeSelector: workload-type: compute-intensive ``` ## Related * [Pipes](/using-pipekit/pipes): how to create and run the Pipes that wrap these Workflows. * [Templates](/concepts/templates) and the [Templates how-to](/using-pipekit/templates): share the `apply` step safely across teams. * [Secrets](/using-pipekit/pipes/edit/secrets): per-environment secrets for cloud credentials. * [Alerting](/using-pipekit/pipes/edit/alerting): fire alerts when drift detection triggers. * [Why Pipekit > Governance](/why-pipekit/governance) and [Why Pipekit > Scale](/why-pipekit/scale): the value-prop framing that maps onto this use case. * [Pipekit CLI](/reference/cli): submit and manage these Workflows from your terminal. # Using Pipekit Day-to-day reference for using Pipekit. This section covers day-to-day work in Pipekit: * [Pipes](/using-pipekit/pipes) and [Runs](/using-pipekit/runs): workflow lifecycle. * [Templates](/using-pipekit/templates), [Argo Events](/using-pipekit/argo-events), [Metrics & Alerts](/using-pipekit/metrics-and-alerts). * [Clusters](/using-pipekit/clusters), [Organizations & Access](/organizations-and-access). * [Operating at Scale](/using-pipekit/operating-at-scale). # Pipes Pipekit enhances the functionality of Argo Workflows by grouping runs of a given Workflow into Pipes. From here you can view and manage all your Pipe's runs in one place. # Edit ## Pipekit Web UI To create a new Pipe, go to the [Pipes tab in Pipekit](https://pipekit.io/pipes) and click the `+ Add pipe` button. From here, choose the Organization the Pipe will belong to, the repo containing the Workflow yaml, and provide a human-friendly name and description. You can choose to permit the running Workflow to access the git repository containing the Workflow yaml. This is useful if the workflow itself needs to access the git repository, for example to obtain stored code. To do this, tick `Grant workflow repository pull access`. For more information, refer to the [Grant workflow repository pull access](#grant-workflow-repository-pull-access) section. You should then choose the [run/sync conditions](/using-pipekit/pipes/edit/run-sync-conditions) for the Pipe. These are the git events that trigger the Pipe to run or a CronWorkflow to sync to your cluster. ### Grant workflow repository pull access By checking `Grant workflow repository pull access`, you can grant a Workflow access to the git repository containing the Workflow yaml. This is done by automatically generating a ssh key and adding it to your git provider. The key is then injected into your cluster as a secret and mounted to your workflow at runtime for you you to use. The generated key is mounted into the `/root` directory of your containers, and is available at the path `/root/.ssh/ssh-deploy-key` for both Github and Gitlab. Here is a simplified example of how you could use the key to access a private repository in your workflow: ```yaml apiVersion: argoproj.io/v1alpha1 kind: Workflow metadata: generateName: clone-repo- spec: entrypoint: clone-repo volumeClaimTemplates: - metadata: name: code spec: accessModes: [ "ReadWriteMany" ] storageClassName: nfs resources: requests: storage: 1Gi templates: - name: clone-repo container: image: alpine command: - sh - -c - | apk --update add openssh-client git eval `ssh-agent -s` mkdir -p /workdir/src/github.com/my_org cd /workdir/src/github.com/my_org ssh-add /root/.ssh/ssh-deploy-key ssh-keyscan github.com > /root/.ssh/known_hosts git config --global --add safe.directory '*' git clone git@github.com:my_org/my_repo.git cd my_repo git checkout $GIT_COMMIT volumeMounts: - name: code mountPath: /workdir resources: requests: memory: 1Gi cpu: 100m ``` {% hint style="info" %} SSH keys are only made available to the Workflow that is triggered by the Pipe. If you have a Workflow that triggers another Workflow or uses workflowTemplates, the keys will not be passed to the second Workflow, or the workflowTemplate. {% endhint %} Pipekit-managed repository pull access is not available for Azure DevOps because Azure DevOps does not support repo-scoped SSH deploy keys. For Azure DevOps, or any workflow that needs custom clone credentials, mount your own Kubernetes Secret into the workflow pod. #### Grant repository access with your own Kubernetes Secret Create a Kubernetes Secret in the namespace where the workflow runs. For SSH clones, store a private key: ```bash kubectl create secret generic git-ssh-key \ --from-file=ssh-privatekey=/path/to/id_rsa \ --namespace= ``` Mount that Secret in the workflow and use it when cloning: ```yaml apiVersion: argoproj.io/v1alpha1 kind: Workflow metadata: generateName: clone-repo- spec: entrypoint: clone-repo volumes: - name: git-ssh-key secret: secretName: git-ssh-key defaultMode: 0400 templates: - name: clone-repo container: image: alpine command: - sh - -c - | apk --update add openssh-client git mkdir -p /root/.ssh cp /git-ssh/ssh-privatekey /root/.ssh/id_rsa chmod 400 /root/.ssh/id_rsa ssh-keyscan ssh.dev.azure.com > /root/.ssh/known_hosts git clone git@ssh.dev.azure.com:v3/// volumeMounts: - name: git-ssh-key mountPath: /git-ssh readOnly: true ``` ## Pipekit CLI You can submit a Pipe to Pipekit using the Pipekit CLI. For more information, refer to the [Pipekit CLI documentation](/reference/cli#submitting-a-workflow). {% hint style="info" %} You cannot grant workflow repository pull access, or choose Run/Sync Conditions when submitting a Pipe via the CLI. {% endhint %} ## Disabling a Pipe If you wish for a Pipe to no longer run, you can disable it. To disable a pipe, you can toggle the switch on the Pipe. This action will prevent any further runs of the Pipe from being triggered. If you change your mind, you can re-enable the Pipe by toggling the switch back on. ## Deleting a Pipe If you wish to delete a Pipe, go to the Pipe UI, and then the settings tab, then click the `Delete` button. You will be asked to confirm the deletion. {% hint style="warning" %} Deleting a Pipe will also delete all Runs and logs associated with the Pipe. Everything associated with the Workflow will be lost when a Pipe is deleted. {% endhint %} # Run/Sync Conditions {% hint style="info" %} This feature is only available to Pipes that have been created via the Pipekit Web UI. {% endhint %} ## Workflows (Run Conditions) You can choose which git event(s) trigger the execution of a Pipe run, and on which cluster the resulting Pipe is executed. You can choose from the following options: * Git Branch * Git Tag * Git Pull/Merge Request For each one, you can choose a specific name (e.g. Branch="main") or a regex (e.g. Branch="^feature/.\*$"). Finally, for each source type and name/regex, you can define which cluster the workflow is executed on. For example, any git branches that match the regex `^feature/.*$` could trigger the Pipe to run on the `dev` cluster, any git branches that match the regex `^release/.*$` could trigger the Pipe to run on the `staging` cluster, and any git branches that match the regex `^main$` could trigger the Pipe to run on the `prod` cluster. You can choose multiple options. If you do so, the Pipe will run if any of the options are met. ## CronWorkflows (Sync Conditions) CronWorkflow Pipes operate slightly differently. As with Open Source, the Argo Workflows instance in your cluster is responsible for scheduling and triggering CronWorkflows. However, you can choose the git conditions which trigger a sync of the CronWorkflow definition from the git repository to the Argo Workflows instance in your cluster. ## Pull/Merge Request Labels If there are labels for your pull/merge requests to be used ([GitHub](https://docs.github.com/en/issues/using-labels-and-milestones-to-track-work/managing-labels), [GitLab](https://docs.gitlab.com/ee/user/project/labels.html)), you can choose which labels will trigger the Pipe Run or the CronWorkflow sync. To use this feature, while creating a Pipe, choose the `Pull Request` Run Condition Source Type, and then select the label(s) you want to match against. When a pull/merge request is submitted to the repository, Pipekit will check if the pull/merge request labels match the Run/Sync condition labels you have selected. The Pipe will then trigger a run if one of the Run/Sync condition labels match the pull/merge request labels. If you leave the labels field blank, the Pipe will run for all pull/merge requests matching the regex. ## Environment variables and Pipe information When triggering a Pipe via git, Pipekit injects some environment variables into the running workflow. These variables can be used to get information about the git event that triggered the Pipe and can be used by the Workflow to make decisions based on that information. | Environment Variable | Description | | -------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- | | `GIT_BRANCH_NAME` | The name of the branch that the pull/merge request belongs to. Blank if triggered by a git tag event. | | `GIT_COMMIT` | Either the sha1 of the pull/merge request. Or the name of the branch or tag that triggered the workflow. | | `GIT_ORG` | The name of the organization that owns the repository that triggered the workflow. For `github.com/pipekit/examples`, it would be `pipekit`. | | `GIT_REPO_NAME` | The name of the repository that triggered the workflow. For `github.com/pipekit/examples`, it would be `examples`. | | `GIT_REQUEST_NUMBER` | The PR/MR number that triggered the Pipe run. Blank if not triggered by a pull/merge request. | | `GIT_SHA` | The sha1 for the commit. Blank if triggered by a git tag event. | | `GIT_TAG` | The git tag name that triggered the Pipe run. Blank if the Pipe run was not triggered by a git tag event. | | `GIT_TARGET_BRANCH` | The name of the target branch of the pull/merge request. Blank if not triggered by a PR/MR. | ### Pipe information Pipekit also injects labels into your running workflow, which you could turn into environment variables: ```yaml apiVersion: argoproj.io/v1alpha1 kind: Workflow metadata: name: get-pipe-info spec: templates: - name: get-pipe-info container: env: - name: RUN_UUID valueFrom: fieldRef: fieldPath: metadata.labels['workflows.pipekit.io/run_uuid'] - name: PIPE_UUID valueFrom: fieldRef: fieldPath: metadata.labels['workflows.pipekit.io/pipe_uuid'] image: alpine command: - sh - -c - | echo "$RUN_UUID" echo "$PIPE_UUID" echo "https://pipekit.io/pipes/$PIPE_UUID/runs/$RUN_UUID" ``` # Secrets You can store key value pairs in Pipekit and have them passed to your running workflow as environment variables. {% hint style="info" %} This feature is only available to Pipes that have been created via the Pipekit Web UI, and only for non-CronWorkflow Pipes. {% endhint %} ## Environments In order to store key-value pairs in Pipekit, you must first create an Environment. Environments can be mapped to a specific [Run Condition](/using-pipekit/pipes/edit/run-sync-conditions). For example, you could have a collection of secrets to be run in a development Run Condition, and another collection of secrets to be run in a production Run Condition, both running on different clusters, with different git events triggering them. To create an Environment, go to the Pipe that you wish to manage, and click the Secrets tab. If there is not already an environment set up for this pipe, you will be prompted to choose an environment name and optional description. If an environment already exists, click the `+ Add Environment` button. Once you have created an Environment, you can add secrets to it. Ensure the environment you wish to use is selected in the Environment dropdown, then add a key/value pair. Click `+ Add Secret` to add another key/value pair. Continue until you have added all the secrets you wish to use, and then click `Save`. ## Adding Secrets to a Run Condition In order to pass the secrets to your running workflow, you must tell Pipekit which Environment each Run Condition should use. Go to the Run Conditions tab and select the environment you wish to use for each run condition. For more information, refer to the [Run Conditions](/using-pipekit/pipes/edit/run-sync-conditions) documentation. ## Using Secrets in your Workflow Key/value pairs are automatically mounted into your workflow as Environment variables. For example, if you entered a key of `MY_SECRET` and a value of `my-secret-value`, you can access this in your workflow as `MY_SECRET`. This example will output `my-secret-value` in the logs: ```yaml apiVersion: argoproj.io/v1alpha1 kind: Workflow metadata: name: test-secret spec: entrypoint: test-secret templates: - name: test-secret container: image: ubuntu command: - /bin/bash - -c - | if [ "${MY_SECRET}" == "my-secret-value" ] then echo "Secrets are working!" echo ${MY_SECRET} else echo "Secrets are not working!" echo ${MY_SECRET} exit 1 fi ``` {% hint style="info" %} Secrets are only made available to the Workflow that is triggered by the Run Condition. If you have a Workflow that triggers another Workflow or uses workflowTemplates, the secrets will not be passed to the second Workflow, or the workflowTemplate. {% endhint %} # Alerting Pipekit Workflow Alerting lets you configure alerts for workflows through Slack or MS Teams integration. You can set alerts on specific workflow statuses such as QUEUED, RUNNING, FAILED or COMPLETED. Alert providers are connected at the Organization level. For more information, refer to the [Managing Alert Providers](/organizations-and-access/alert-providers) documentation. ## Add Alert Rules 1. Once you have connected an alert provider, click on `Pipes` from the Navbar to navigate to `pipekit.io/pipes` where you'll see a list of pipes. 2. Select the pipe that you want to add alerts for. You'll be redirected to the pipe details page for your selected pipe. 3. Click on the `Alert Rules` tab. You will be prompted to select your alert provider, workflow status such as QUEUED, RUNNING, FAILED, COMPLETED etc and a specific alert message of your choice. ### Alerting specific Slack users For Slack only, you can mention specific Slack users in alerts by referencing them by their Member ID. To find a Slack user's Member ID, navigate to their profile in Slack, click the ellipsis menu, and select "Copy Member ID". Paste this ID into the "CC Users" field in the Pipekit UI when adding your alert rule. You can alert multiple users in the same alert by separating their Member IDs with a comma. ## Validate Workflow Alerts 1. Head to your Slack or MS Teams workspace and find the channel you selected when you connected your alert provider to Pipekit. 2. In that channel, you should see the alert that was added for your selected pipe. 3. Validate the alert by clicking on the link in the alert where you can check the workflow's execution status on the Pipekit UI. # Cron CronWorkflows Pipekit supports **creating**, **updating**, **suspending**, **resuming** and **deleting** Argo CronWorkflows. You can issue commands for CronWorkflows in multiple different ways: * git events * [Pipekit CLI](/reference/cli) * [Hera](https://github.com/argoproj-labs/hera) workflows ## git events ### CREATE action To create (submit) a CronWorkflow via git events, you must create a Pipe and link a `.yaml` file to the CronWorkflow in the repo. Then when a [Sync Condition](/using-pipekit/pipes/edit/run-sync-conditions) is triggered, the [Pipekit Agent](/concepts/pipekit-agent) will submit the CronWorkflow to the Cluster. {% hint style="info" %} Only one CronWorkflow YAML can run with a single Pipe on the same cluster. Every git event after the initial one updates the existing CronWorkflow. A Pipe is linked to only one `.yaml` file, so it is assumed that this is the same CronWorkflow and only updates are executed on that same CronWorkflow. This means no new CronWorkflow is triggered. If this restriction is too heavy, send us feedback via Slack or . {% endhint %} ### UPDATE action To update a CronWorkflow via git events, the procedure is the same as for `CREATE` action. If you push another commit that triggers the same Pipe, the [Pipekit Agent](/concepts/pipekit-agent) knows that the CronWorkflow is already running and in this case it will update it. ### SUSPEND and RESUME actions To suspend all CronWorkflows within the Pipe, use the toggle in the web interface to mark the Pipe as `disabled`, this will trigger the [Pipekit Agent](/concepts/pipekit-agent) to suspend *ALL* the CronWorkflows associated with the Pipe. To resume all suspended CronWorkflows within the Pipe, use the toggle in the web interface to mark the Pipe as `enabled`, this will trigger the [Pipekit Agent](/concepts/pipekit-agent) to resume *ALL* the CronWorkflows associated with the Pipe. ### Alternative ways to suspend and resume CronWorkflows Using Git and the YAML manifest: * Set `.spec.suspend: true` in the `.yaml` manifest to mark that CronWorkflow should be suspended and then trigger a new git event. * Set `.spec.suspend: false` in the `.yaml` manifest to mark that CronWorkflow should be resumed and then trigger a new git event. {% hint style="warning" %} Note: If you are using a Branch Sync Condition, be mindful of how your YAML manifest differs across branches. Pipekit does not track or enforce YAML manifest changes across branches. {% endhint %} Using the Pipekit CLI: * Refer to the [Pipekit CLI documentation](/reference/cli/cron-workflows) for how to suspend or resume specific CronWorkflows on a given cluster and namespace instead of suspending or resuming all CronWorkflows within a Pipe. ### DELETE action To delete a CronWorkflow, you can select `Delete` under the Settings tab of the Pipe. This will trigger the [Pipekit Agent](/concepts/pipekit-agent) to delete *ALL* the CronWorkflows associated with the pipe on *ALL* clusters. {% hint style="warning" %} Deleting a Pipe will also delete all Runs and logs associated with the Pipe. Everything associated with the CronWorkflow will be lost when a Pipe is deleted. {% endhint %} ### `generateName` vs `name` for CronWorkflows Pipekit treats `generateName` inside the CronWorkflows definition in [the same way as `kubernetes` and `argo` do](https://kubernetes.io/docs/reference/using-api/api-concepts/#generated-values). So, submitting multiple runs of the same CronWorkflow that are using `generateName` instead of `name` will result in multiple `CronWorkflows` submitted to the cluster with unique names, which can cause duplicate workflows (or Pipes in the Pipekit UI) based on the same cron schedule. This can be a problem when using `generateName` while submitting CronWorkflow through git events. When a new git event triggers a Sync Condition (i.e. if a new commit is pushed), Pipekit/Argo Workflows will create new CronWorkflow, and **will not** update the existing one. To avoid this, **we recommend using** `name` **instead of** `generateName` **in your CronWorkflow manifests** if you want to update the existing CronWorkflow Pipe instead of creating a new one. ## Pipekit CLI For information on interacting with CronWorkflows using the Pipekit CLI, refer to the [Pipekit CLI documentation](/reference/cli/cron-workflows). ## Hera An example for how to define a CronWorkflow with [Hera](https://github.com/argoproj-labs/hera) and submit it to Pipekit with the Pipekit SDK: ```py from hera.workflows import Container, CronWorkflow from pipekit_sdk.service import PipekitService import os pipekit = PipekitService(token=os.environ["PIPEKIT_TOKEN"]) with CronWorkflow( name="cron-wf-example", namespace="argo", entrypoint="main", schedule="*/5 * * * *", starting_deadline_seconds=0, concurrency_policy="Replace", service_account_name="argo-workflow" ) as w: main = Container( name="main", image="alpine", command=["sh", "-c", "echo \"I am a CronWorkflow\" && echo \"It is currently $(date)\""], ) pipekit.create(w, "my-cluster") ``` ### CREATE action To create a CronWorkflow with Hera Workflows: ```python cw.create() ``` ### UPDATE action To update: ```python cw.update() ``` ### SUSPEND action To suspend: ```python cw.suspend() ``` ### RESUME action To resume: ```python cw.resume() ``` ### DELETE action To delete: ```python cw.delete() ``` # Externally Triggered Externally-triggered Workflows Pipekit supports the ability to query your cluster for Workflows that have not been triggered by Pipekit. It will then display the workflow details in a Pipe and Runs accordingly. This feature is useful if you are transitioning to Pipekit and already have a preferred method of triggering Workflows, or you intend to keep using your existing method instead of triggering Workflows through Pipekit. ## How to enable This feature is disabled by default. To enable it, you need to modify your [pipekit-agent installation](/concepts/pipekit-agent#enabling-externally-triggered-workflows). {% hint style="warning" %} CronWorkflows are not supported by this feature. {% endhint %} {% hint style="info" %} All users in the Pipekit Organization will see externally-triggered Workflows in the [Runs dashboard](/using-pipekit/runs) of the Pipekit UI. {% endhint %} # Runs You can view all recent runs belonging to your organization(s). ## Recent Runs You can view the recent runs belonging to your organization(s) by going to the [Runs tab in Pipekit](https://pipekit.io/runs). From here you can see all past runs of the Pipe. The view allows you to understand what [Run Conditions](/using-pipekit/pipes/edit/run-sync-conditions) triggered the run, the cluster the run ran on, the status of the run, the current progress of the run (if still running), the time the run started, and the duration of the run. ## More information about a Run To see detailed information about a run, click on it. This action will direct you to the run graph, where you can view the [graphical representation of the run](/using-pipekit/runs/run-graph), check the [pod logs](/using-pipekit/runs/pod-logs), and review the [workflow logs](/using-pipekit/runs/workflow-logs). ## Linking to Pipekit Pipe Runs from the Argo Workflows UI You can add a link to the Argo Workflows UI that takes users from a Workflow in Argo Workflows directly to the corresponding Run in Pipekit. Add the following to your Workflow Controller ConfigMap: ```yaml apiVersion: v1 kind: ConfigMap metadata: name: workflow-controller-configmap data: links: | # Adds a button to the workflow page that takes the user to the Pipe Run in Pipekit - name: View in Pipekit scope: workflow url: https://pipekit.io/pipes/${workflow.metadata.labels.workflows.pipekit.io/pipe_uuid}/runs/${workflow.metadata.labels.workflows.pipekit.io/run_uuid} # Adds a button to the sidebar that takes the user to the pod's details view in Pipekit - name: View in Pipekit scope: pod url: https://pipekit.io/pipes/${workflow.metadata.labels.workflows.pipekit.io/pipe_uuid}/runs/${workflow.metadata.labels.workflows.pipekit.io/run_uuid}/workflow?pod-name=${metadata.name} ``` Then restart your Workflow Controller and Argo Server instances. # Inspect Pipekit Pipes collect workflow runs in a logical group. You can view all runs of a given workflow in a Pipe, even across Kubernetes clusters. You can view the runs of a Pipe by going to the [Pipes tab in Pipekit](https://pipekit.io/pipes) and clicking on the Pipe you wish to view the runs of. From here you can see all past runs of the Pipe. The view allows you to understand what [Run Conditions](/using-pipekit/pipes/edit/run-sync-conditions) triggered the run, the cluster the run ran on, the status of the run, the current progress of the run (if still running), any output message from Argo Workflows, the time the run started, and the duration of the run. ## Cron Pipes You can also see past [Cron Workflow](/using-pipekit/pipes/cron) runs in the same way. Click the Pipe you want. If the underlying workflow was a Cron Workflow, you can see information about the cron schedule, as well as the standard Pipe run information. ## Stopping a running Run If a run is still running, you can stop it by clicking the checkbox to the left of the run, and then clicking the `Stop` button at the top of the page. This will gracefully stop the run, and the run will be marked as `Stopped` in the list of runs. {% hint style="info" %} A `Stop` command is an asynchronous command. It may take a few moments for the run to stop, especially if your workflow has an exit handler that needs to complete before the run can be gracefully stopped. {% endhint %} ## Resubmitting a Run You can resubmit a run by clicking the checkbox to the left of the run, and then clicking the `Resubmit` button at the top of the page. This will create a new run of the workflow, with the same parameters as the original run. {% hint style="info" %} You can only resubmit a run if it is no longer running. {% endhint %} ## More information about a Run You can view more information about a given run by clicking on the run. This will take you to the run graph for the run. From here you can see the [run graph](/using-pipekit/runs/run-graph) for the run, the [pod logs](/using-pipekit/runs/pod-logs) for the run, and the [workflow logs](/using-pipekit/runs/workflow-logs) for the run. ## Data Retention Pipekit will retain all runs for a Pipe. There is no limit to the number of runs that will be retained or the time period that they will be retained for. # Run Graph You can view a DAG for your workflow that updates as your workflow runs. The toolbar offers a few options for viewing the DAG: * Horizontal/Vertical Layout - Allows you to change the layout of the DAG. * Zoom Out - Allows you to zoom out of the DAG. * Zoom Reset - Resets the zoom level of the DAG. * Zoom In - Allows you to zoom in on the DAG. * Faster render - Shows the DAG using a faster, but less pretty renderer. * Toggle Artifacts - show/hide artifacts in the DAG. * Collapse All Nodes - Collapses all nodes in the DAG. * Expand All Nodes - Expands all nodes in the DAG. If you click on a node in the DAG, you can see all parents and children of that node. # Pod Logs Clicking the Logs tab allows you to see all the logs generated by the pods created during your workflow run. ## Downloading Pod Logs Click the `Download` button to download the logs for the run. This will download a text file containing logs that conform with both your [filter](#filtering-logs) and [search](#searching-logs) criteria. ## Filtering Logs By default, you are shown only the `main` container logs for each pod running in your workflow. You can click the `Advanced Filters` button to include other container logs. You can also choose individual Pods or Nodes to view. ## Searching Logs Click the `Search` icon button to open the search box (or hit Ctrl + F / Cmd + F).\ Enter a string in the search box. This will filter the logs to only show logs that contain the string you entered.\ You can search through logs by hitting the previous and next buttons, or by hitting Enter to go to the next search result (Shift + Enter to go to the previous search result). **Expanding Context** If the `Show context logs when filtering` option is activated, expanding buttons appear next to matches. Click a button to reveal more lines around the match. Click again to expand further. Changing your search or filters resets the view to collapsed. ## Viewing Logs In order to help make log analysis more efficient, Pipekit automatically helps identify errors by coloring the logs. ## Log Level Detection Pipekit automatically detects and highlights log levels in your workflow logs. ### Supported Log Levels | Level | Display | Displayed color | Keywords Recognized | | ------------ | ---------- | --------------- | ------------------------------------------------------------------- | | **Critical** | `critical` | Purple | `emerg`, `emergency`, `fatal`, `alert`, `crit`, `critical`, `panic` | | **Error** | `error` | Red | `err`, `eror`, `error`, `fail`, `failed`, `failure` | | **Warning** | `warning` | Orange | `warn`, `warning` | | **Info** | `info` | Green | `info`, `information`, `informational`, `notice` | | **Debug** | `debug` | Blue | `dbug`, `debug` | | **Trace** | `trace` | Pastel Blue | `trace`, `verbose` | | **Default** | `unknown` | Gray | | ### Supported Log Formats The detection system recognizes the most common logging formats used in production systems. #### JSON Structured Logs ```json {"level": "error", "message": "Connection failed"} {"severity": "warn", "msg": "Retry attempt 3"} {"lvl": "INFO", "event": "User logged in"} ``` Recognized field names: `level`, `severity`, `lvl`, `log_level`, `loglevel` #### Key-Value / Logfmt ``` level=error msg="Connection failed" severity=warning component=api loglevel=debug request_id=abc123 ``` #### Syslog Format ``` <3>Mar 6 12:00:00 myhost myapp: Connection failed <27>Error message with facility ``` The numeric priority value follows RFC 5424: `priority = facility × 8 + severity` | Severity | Level | | -------- | --------- | | 0 | Emergency | | 1 | Alert | | 2 | Critical | | 3 | Error | | 4 | Warning | | 5 | Notice | | 6 | Info | | 7 | Debug | #### Bracketed Format ``` [ERROR] Connection failed [WARN] Retry attempt 3 [INFO] Server started [E] Short error format [W] Short warning format ``` #### Timestamp-Prefixed Logs ``` 2024-01-15T10:30:00Z ERROR Connection failed 2024-01-15 10:30:00 WARN Retry attempt 2024/01/15T10:30:00.123+00:00 INFO Server started ``` #### Colon-Separated Format ``` ERROR: Connection failed WARN: Retry attempt 3 INFO: Server started on port 8080 ``` #### Pipe-Separated Format ``` myapp | ERROR | Connection failed service | WARN | High memory usage ``` #### Android Logcat Style ``` E/MyApp: Connection failed W/MyService: Retry attempt I/MainActivity: onCreate called ``` #### Plain Text (Fallback) When no structured format is detected, the system searches for log level keywords anywhere in the message: ``` Connection error occurred Warning: disk space low This is an info message about the system ``` ### Detection Priority When a log line contains multiple potential log levels, the system: 1. **Finds all matches** from both structured patterns and keyword occurrences 2. **Selects the earliest match** by position in the line 3. **If tied**, selects the higher severity level #### Example ``` 68:5 warning Error: Cannot access refs during render ^ ^ | | wins loses (appears later) ``` Result: `warning` (appears at position 7, before `Error` at position 17) This ensures that prefixed severity indicators (like linter output or log framework prefixes) take precedence over error keywords that may appear in the message content. ### Unrecognized Logs Logs that don't match any pattern are assigned the `unknown` level and displayed with neutral styling. ### Log Resource Selector Pipekit supports the Argo Workflows log resource selector as described in [this example](https://github.com/argoproj/argo-workflows/blob/master/examples/k8s-resource-log-selector.yaml). By applying this label to Kubernetes resources, logs from these resources will be displayed within Pipekit. ## Log Retention Pipekit stores logs for 1 year. Logs older than 1 year are automatically deleted. If you wish to use a custom log retention period, consider bringing your own logging solution and [integrating it with Pipekit](/organizations-and-access). # Workflow Logs The Workflow tab shows your run as a hierarchical table: every step with its status, duration, pod names, output artifacts, error messages, and resource duration. ## Collapse children by default Large workflows can produce hundreds of rows once every per-stage scaffolding step (`lock-cache`, `await-image`, `clone`, …) is expanded. Mark a template as a logical stage and Pipekit will render its direct children collapsed by default — users still expand and re-collapse freely. Add this annotation to the template that declares the `dag:` or `steps:` body: ```yaml metadata: annotations: workflows.pipekit.io/ui-collapsed: "true" ``` Any value other than the case-sensitive string `"true"` (missing, empty, `"false"`) keeps the default expanded behavior. ### Failed runs expand to show the failure The annotation never hides a failure. When the table mounts, Pipekit expands every stage on the path from the workflow root down to each `Failed` or `Error` node, even if that stage is annotated `ui-collapsed: "true"`. So a failed run opens with its failures visible, and you do not have to hunt through collapsed stages to find what broke. This happens once, at mount. From there collapse state follows only your own clicks — a stage that fails later in a live run will not re-expand a row you have since collapsed. ## Where the annotation can live The annotation is resolved identically whether the template is: * declared inline in `workflow.spec.templates`, * declared in a `WorkflowTemplate` referenced via `templateRef`, * declared in a `ClusterWorkflowTemplate` referenced via `templateRef`, or * reached through a chain of refs up to ten levels deep. Put it on whichever template you own that declares the stage. # Workflow YAML Clicking the YAML tab allows you to see the raw YAML representation of your executed workflow. This is useful for debugging and understanding the structure of your workflow. # Templates Pipekit enhances the Workflow Templates functionality of Argo Workflows by allowing you to version control your Workflow Templates and share them across multiple clusters. {% hint style="info" %} The Templates documentation can be followed for both Cluster Workflow Templates and Workflow Templates. To simplify things, "Workflow Templates" will be used throughout the documentation, but unless specified, will refer to both. {% endhint %} For further information on Workflow Templates, see [the Argo Workflows documentation](https://argoproj.github.io/argo-workflows/workflow-templates/). For a worked example that uses a Template to scope a Terraform `apply` step to authorized users, see the [Infrastructure as Code with OpenTofu](/use-cases/infrastructure-as-code) use case. ## Creating a Workflow Template You can create your Workflow Templates in the usual manner. However, once you have written them you do not need to apply them to your cluster. Instead, you need to add them to your git repo and to make Pipekit aware of the Workflow Template. Pipekit will then manage the lifecycle of the Workflow Template in your cluster(s). ### Adding a Workflow Template to Pipekit Go to the [Templates tab in Pipekit](https://pipekit.io/templates) and click on the `+ Add workflow templates` button. Choose the organization, git repository and path of the Workflow Template within the git repository. You can also add a human-friendly name and description for the Workflow Template. ### Bulk adding Workflow Templates to Pipekit If you have multiple Workflow Templates in the same directory within a git repository, tick `Include templates from folder`, define the path to the folder, and Pipekit will bulk import your Workflow Templates. ## Editing a Workflow Template in Pipekit You can edit the name and description of your Workflow Template in Pipekit. Click the Workflow Template you want to edit and go to the `Settings` tab. Click the `Edit` button. ## Deleting a Workflow Template from Pipekit You can delete a Workflow Template from Pipekit by clicking on the Workflow Template you wish to delete and going to the Settings tab. Click the `Delete` button. ## Submitting a Workflow Template ### Submitting a standalone template Go to the [Templates tab in Pipekit](https://pipekit.io/templates), find the Workflow Template you wish to submit to your cluster and click the radio button next to it. Then click the `Submit` button. You then need to choose the cluster you wish to submit the Workflow Template to, as well as the [template version](#workflow-templates-version-control). After this, you have the option to choose the namespace you wish to run your Workflow Template in and you can choose the entrypoint. Finally, if your Workflow Template had global parameters set, you can set the values for these parameters prior to submitting the Workflow Template. Once you have pressed `Submit`, Pipekit will apply the Workflow Template to your cluster. A link will be presented allowing you to watch the Pipe run. ### Submitting a Workflow Template as part of a Pipe You can reference one or more Workflow Template(s) as part of a regular workflow using `templateRef` in your workflow spec. For example: ```yaml apiVersion: argoproj.io/v1alpha1 kind: Workflow metadata: generateName: example-wf- spec: entrypoint: main templates: - name: main dag: tasks: - name: run-workflow-template templateRef: name: my-workflow-template template: main ``` ## Workflow Templates version control Pipekit will automatically track changes to your Workflow Templates. You can make new versions by creating a git tag in your git repository. Pipekit will automatically detect the new version and update the Workflow Template in Pipekit. Pipekit also makes the `latest` version of your Workflow Template available to use by tracking your default repository branch (typically this is `main`). You can view all the versions of a template by clicking on the template in the [Templates tab in Pipekit](https://pipekit.io/templates) and selecting the version you wish to view. ### Pinning a Workflow Template version If you have a workflow that references a Workflow Template, you can pin the version of the Workflow Template that the workflow uses. This means that if you make changes to the Workflow Template, the workflow will not be affected. To pin a Workflow Template version, you can use the `pipekit-io-templates-gitRef` label in your workflowMetadata. For example: ```yaml apiVersion: argoproj.io/v1alpha1 kind: Workflow metadata: generateName: wf-name- spec: entrypoint: main workflowMetadata: labels: pipekit-io-templates-gitRef: v1.0.1 ... ``` The above example will apply globally to all Workflow Templates referenced by the workflow. You can override the template version at the template level too: ```yaml apiVersion: argoproj.io/v1alpha1 kind: Workflow metadata: name: wf-name spec: entrypoint: main workflowMetadata: labels: pipekit-io-templates-gitRef: v1.0.1 arguments: parameters: - name: global-parameter value: hello templates: - name: main arguments: parameters: - name: message value: "{{workflow.parameters.global-parameter}}" - name: pipekit-io-templates-gitRef value: "v1.0.2" templateRef: name: whalesay-template template: whalesay - name: another-whalesay arguments: parameters: - name: message value: "{{workflow.parameters.global-parameter}}" templateRef: name: whalesay-template template: whalesay ... ``` In the above example, the workflow will use `v1.0.1` of the Workflow Template globally, so the `another-whalesay` task will use version `v1.0.1` of the referenced template, but the `whalesay` task will use version `v1.0.2` of the Workflow Template. # Argo Events Trigger Pipekit runs from Argo Events sources [Argo Events](https://argoproj.github.io/argo-events/) is an event-driven automation framework for Kubernetes. It listens to sources such as webhooks, message queues, cloud events, and calendars, and fires a trigger when an event arrives. Pipekit exposes an Argo Events custom trigger, so any of those sources can launch a Pipekit run. When a Sensor fires, it submits an inline Argo Workflow to Pipekit as a governed [Run](/using-pipekit/runs). The run is routed to the [Cluster](/using-pipekit/clusters) you name, respects your organization's permissions, and appears in the [Runs dashboard](/using-pipekit/runs) with the `Argo Events` source label. This lets you keep your existing event-driven pipelines while gaining Pipekit's observability and access control over what they launch. ## How it works The trigger is a gRPC `custom` trigger on your Argo Events Sensor. The Sensor dials the Pipekit control plane at `api.pipekit.io:443` over TLS and authenticates with your cluster API key. Pipekit reads the inline workflow from the trigger spec, resolves the target cluster by name within your organization, and submits the run. ## Prerequisites You need an Argo Events installation in the cluster that runs your Sensor. Install it with Pipekit's build of Argo Events rather than the upstream images. {% hint style="warning" %} The Pipekit custom trigger uses `authToken` and `authHeader` fields that are not in upstream Argo Events. Both the `controller-manager` Deployment and the Sensor pods must run the Pipekit image `pipekit13/argo-events`. Stock Argo Events images will not attach the API key, and the trigger will fail to authenticate. {% endhint %} You also need a registered Pipekit cluster and its API key. The API key is shown when you [add a cluster](/using-pipekit/clusters) and can be [regenerated](/using-pipekit/clusters#generating-a-new-api-key) from the cluster's `Settings` tab. Note the cluster's name as well, which you set when creating it. ## Configure ### Store the cluster API key as a Secret Create a Kubernetes Secret in the Sensor's namespace holding your cluster API key. ```yaml apiVersion: v1 kind: Secret metadata: name: pipekit-cluster-apikey namespace: argo-events type: Opaque stringData: apiKey: "" ``` ### Add the custom trigger to your Sensor Add a `custom` trigger to your [Sensor](https://argoproj.github.io/argo-events/concepts/sensor/) that points at the Pipekit control plane. ```yaml apiVersion: argoproj.io/v1alpha1 kind: Sensor metadata: name: pipekit-run namespace: argo-events spec: dependencies: - name: webhook-dep eventSourceName: webhook eventName: pipekit triggers: - template: name: pipekit-submit custom: serverURL: api.pipekit.io:443 secure: true authHeader: X-PIPEKIT-API-KEY authToken: name: pipekit-cluster-apikey key: apiKey spec: cluster: "my-cluster" workflow: | apiVersion: argoproj.io/v1alpha1 kind: Workflow metadata: generateName: argo-events- namespace: argo spec: entrypoint: main arguments: parameters: - name: message value: "default message" templates: - name: main inputs: parameters: - name: message container: image: alpine:3.20 command: [sh, -c] args: ["echo {{inputs.parameters.message}}"] parameters: - src: dependencyName: webhook-dep dataKey: body.message dest: spec.arguments.parameters.0.value ``` ### Trigger fields | Field | Required | Description | | --------------- | -------- | ------------------------------------------------------------------------------------- | | `serverURL` | Yes | The Pipekit control plane gRPC endpoint. Use `api.pipekit.io:443`. | | `secure` | Yes | Set to `true`. The connection uses TLS. | | `authHeader` | Yes | Set to `X-PIPEKIT-API-KEY`. This is the header Pipekit reads the API key from. | | `authToken` | Yes | A reference to the Secret key holding your cluster API key. | | `spec.cluster` | Yes | The name of the Pipekit cluster to run on. Must match a cluster in your organization. | | `spec.workflow` | Yes | The inline Argo Workflow to submit, as a YAML string. | | `parameters` | No | Standard Argo Events parameter injection into the resolved workflow. | `api.pipekit.io` serves a publicly trusted certificate, so no `certSecret` is needed. ### Inject event data Use the trigger's `parameters` block to inject values from the event into the submitted workflow, the same way any Argo Events trigger does. The `src` selects a value from the event payload, and `dest` is a path into the trigger spec. In the example above, the webhook body's `message` field replaces the workflow's `message` parameter. ## Verify Fire an event at your source, then open the [Runs dashboard](/using-pipekit/runs). Filter the source to `Argo Events` to find the run. The run behaves like any other Pipekit run once submitted. # Metrics & Alerts Pipekit Workflow Metrics Pipekit collects OpenTelemetry metrics from your Argo Workflows and Kubernetes cluster and displays them as dashboards at [Pipekit](https://pipekit.io/metrics). To enable metrics on a new account, see [Get Started](/get-started/evaluate-cloud). If you are an existing Pipekit user, contact us through your Slack support channel or email `hello@pipekit.io` and we will enable the metrics feature for your existing cluster(s). ## Data The Pipekit Agent uses OpenTelemetry to collect metrics from your Kubernetes cluster. The metrics are sent to the Pipekit backend where they are sanitized, stored, and retrieved for visualization. We only collect metrics that are then shown in the Pipekit dashboard. We do not collect any other data from your cluster. You can view the OpenTelemetry configuration by inspecting the Pipekit Agent Collector configmap in your cluster. ### Data Retention Pipekit retains your metrics data for 10 days before destroying it. If you need to extend this period, contact us through your Slack support channel or email `hello@pipekit.io`. # Clusters Connect multiple clusters to Pipekit, and run workflows on different Kubernetes clusters while managing access and viewing the workflow results in one central dashboard. If your cluster does not yet have Argo Workflows installed, you can use [the Pipekit Agent](/concepts/pipekit-agent) to install Argo Workflows. ## Connect a Kubernetes Cluster to Pipekit Go to the [Clusters tab in Pipekit](https://pipekit.io/clusters) and click on the `+ Connect Cluster` button. You will be prompted to select an [organization](/organizations-and-access) to connect the cluster to. Choose an appropriate name and description for your cluster. It is recommended to use a name that is all lowercase with no whitespace. Choose which namespace you intend to install the Pipekit Agent. Common namespaces are `default` and `pipekit`, although you can choose any namespace you wish, including the namespace where Argo Workflows resides (by default, `argo`). Press `Submit` when you are ready to proceed. ### API Key You will be presented with a unique API key for your cluster. You will need this API key to install the Pipekit Agent on your cluster. It will only be shown to you once, so make sure to copy it and store it somewhere safe. [You can always generate a new API key if you lose it](#generating-a-new-api-key), but this will immediately invalidate the old key. #### Pipekit Agent Installation Options You can install the Pipekit Agent on your cluster using either a Kubernetes YAML Manifest or [Helm Chart](/reference/helm-values/agent). Your browser will have automatically downloaded the YAML manifest for you. Once you have installed the Pipekit Agent, the `Waiting for cluster to come online` indicator will turn green and you can click `Close`. ## Clusters View You can see all your clusters in the [Clusters tab in Pipekit](https://pipekit.io/clusters). Clusters with a red indicator are not currently able to communicate with the Pipekit API. A green indicator denotes a successfully connected agent. If you have installed the Pipekit Agent, but do not see the green indicator, check the logs of the Pipekit Agent pod for errors. If you click a given cluster, you can view all runs across all Pipes for that cluster. ### Pipekit Agent Version The version of the installed Pipekit Agent is shown to the left of the red/green connection indicator. It is important to keep your Pipekit Agent up to date, as it will ensure you have the latest features and bug fixes. The Pipekit Agent is always released alongside the Pipekit CLI and Helm chart with the same version number. You can check the latest version of the Pipekit Agent by either looking at available [Pipekit CLI](/reference/cli) versions, available [Helm chart](/reference/helm-values/agent#checking-the-latest-version) versions or by looking at the Pipekit Agent image tags on [Docker Hub](https://hub.docker.com/r/pipekit13/pipekit-agent/tags). ### Modifying a cluster You can modify a cluster by clicking on the cluster name. This will take you to the cluster details page where you can navigate to the Settings tab to change the cluster name, description and API key. You can also make the cluster inactive or delete it from here. Toggling the active state on each cluster is how you trigger the [Disaster Recovery](/using-pipekit/clusters/disaster-recovery) failover, including the automatic queue cleanup when a cluster comes back online. #### Generating a new API key If required, you can generate a new API key for your cluster by clicking "Rotate API Key" on the cluster settings tab. This will immediately invalidate the old API key. ### Queuing By default, Pipekit operates a first-in-first-out (FIFO) queue by treating the priority of all submitted workflows as the same. This means that if you submit two workflows to Pipekit, the first workflow will be submitted to your cluster before the second workflow. If you submit a third workflow, it will be submitted after the second workflow. At scale, this may be problematic as short-running jobs may get backed up behind longer-running jobs and this may not meet your business needs. You can define priority groups for workflows at a cluster level by clicking on the cluster name and navigating to the Queuing tab. By default, all workflows are given a priority of `3`. If you want some workflows to have a higher priority, enter an appropriate name in the Workflow Group ID field (e.g. `highest-priority`) and select `1 (Highest)` in the dropdown before saving. Any workflows with the label `workflows.pipekit.io/workflow_group_id: "highest-priority"` running in this cluster will be given a higher priority than other workflows. Similarly, if you wish to give some workflows a lower priority, enter an appropriate name in the Workflow Group ID field (e.g. `lowest-priority`) and select `5 (Lowest)` in the dropdown before saving. Again, any workflows with the label `workflows.pipekit.io/workflow_group_id: "lowest-priority"` running in this cluster will be given a lower priority than other workflows. {% hint style="info" %} The priority is given to the *submission* of the workflow and not to the pods within the workflow. For the avoidance of doubt, setting the queue priority does not increase the [Pod Priority](https://kubernetes.io/docs/concepts/scheduling-eviction/pod-priority-preemption/) of the pods within the workflow. This is something that should be configured in the workflow and the kubernetes cluster itself. {% endhint %} # Disaster Recovery Run Pipekit workflows continuously across primary and secondary clusters in separate regions, with manual failover when the primary is unavailable. Run Pipekit workflows continuously across a primary and secondary cluster in separate regions, with manual failover when the primary region is unavailable. This pattern fits operators with a contractual recovery time objective and operators who run business-critical workflows where losing the primary cluster requires a disaster recovery plan. Pipekit gates and coordinates the cluster-level routing through admin-only controls and queue cleanup; the surrounding infrastructure remains your responsibility as the operator. ## Overview The pattern uses two Kubernetes clusters connected to the same Pipekit organization, each running the Pipekit Agent. Only one cluster is active at a time. Workflow submissions target the active cluster by passing its name to the `--cluster-name` flag on `pipekit submit`. Failover is a short sequence of REST calls that flip the `isActive` flag on each cluster, run from a CI pipeline you trigger when the primary region is unhealthy. ```mermaid graph LR Operator[Operator or CI] CLI[Pipekit CLI] CP[Pipekit Control Plane] subgraph RegionA["Primary cluster (Region A, active)"] AgentA[Pipekit Agent] ArgoA[Argo Workflows] end subgraph RegionB["DR cluster (Region B, inactive)"] AgentB[Pipekit Agent] ArgoB[Argo Workflows] end Operator -->|pipekit submit --cluster-name| CLI CLI --> CP CP -->|active| AgentA CP -.->|inactive| AgentB AgentA --> ArgoA AgentB --> ArgoB ``` Failover flips `active` and `inactive` on each cluster via `PUT /clusters/{cluster-uuid}`. ## What Pipekit provides Pipekit owns three pieces of the failover that you would otherwise have to build yourself. * **Admin-only state changes.** Only organization admins can toggle a cluster between `active` and `inactive`. The check is enforced at the control plane, not at the CI layer, so a leaked CI credential cannot flip cluster state. * **Automatic queue cleanup on reactivation.** When a cluster transitions from `inactive` back to `active`, Pipekit clears any workflows submitted while the cluster was `inactive`. Stale submissions that were enqueued before the failover do not replay when the primary comes back online. * **A single audited toggle.** The active state is one field on one resource; flipping it is one REST call. Operators do not have to coordinate routing changes across multiple Pipekit objects. ## Prerequisites * Two Kubernetes clusters in separate regions, each able to run Argo Workflows. * The Pipekit Agent installed on both clusters, following [Connect a Kubernetes Cluster to Pipekit](/using-pipekit/clusters). * Pipekit credentials for an organization admin (only admins can toggle cluster state). Store the username and password in a Kubernetes Secret on the cluster that runs the failover workflow. The failover example authenticates with the Pipekit CLI, following the [container login pattern](/reference/cli#docker-container), so a short-lived bearer token does not need to be persisted anywhere. * A system to run the failover steps. Any CI tool that can call the Pipekit REST API works (Azure DevOps, GitHub Actions, GitLab CI), or you can use Pipekit itself by submitting an Argo Workflow to a third, always-active cluster. {% hint style="info" %} This page covers Pipekit's role in the failover. Surrounding infrastructure such as database replication, secrets sync, DNS updates, and image registry availability is your responsibility. Coordinate the Pipekit steps with your wider DR plan. {% endhint %} ## Preparing the secondary cluster Bring the secondary cluster up in its target region and register it under the same organization as the primary. Install the Pipekit Agent and confirm the green connection indicator in the `Clusters` view. Set the secondary cluster inactive immediately after the Agent reports healthy. Run `pipekit update cluster --status=inactive` (or PUT `/api/users/v1/clusters/{cluster-uuid}` with `{"isActive": false}` against the REST API). This prevents accidental submissions while the primary is the active cluster. ## Failing over to the secondary cluster Trigger your CI pipeline when you decide to fail over. The pipeline runs three steps against the Pipekit REST API. 1. Mark the primary cluster inactive. Run `pipekit update cluster --status=inactive` (or PUT `/api/users/v1/clusters/{primary-uuid}` with `{"isActive": false}` against the REST API). New submissions targeted at the primary are rejected with the error `trying to start workflow on inactive cluster`. 2. Mark the secondary cluster active. Run `pipekit update cluster --status=active` (or PUT `/api/users/v1/clusters/{dr-uuid}` with `{"isActive": true}`). 3. Switch the value passed to `--cluster-name` on every `pipekit submit` invocation to the secondary cluster's name. The `--cluster-name` flag is required and has no environment-variable fallback, so every submission job in your pipeline must read the cluster name from a shared variable. {% hint style="warning" %} Setting a cluster inactive blocks new submissions only. Workflows already running on the primary continue until they complete or until the region becomes unreachable. Plan for in-flight work to remain on the primary; the failover does not drain it. {% endhint %} ## Example: Argo Workflow The Argo Workflow below performs the failover by calling `pipekit update cluster` against two clusters in sequence. Submit it to a third, always-active cluster that hosts your ops workflows. That cluster must not share a region with the primary or the secondary; if it does, it goes down with them. Store the Pipekit admin credentials in a Kubernetes Secret named `pipekit-credentials` on the third cluster, with the username under the `username` key and the password under the `password` key. The workflow re-authenticates each run via `pipekit login`, so a short-lived bearer token is never persisted. See [Used within a Workflow](/reference/cli#used-within-a-workflow) for the underlying pattern. ```yaml apiVersion: argoproj.io/v1alpha1 kind: Workflow metadata: generateName: pipekit-failover- spec: entrypoint: failover arguments: parameters: - name: from-cluster-name - name: to-cluster-name templates: - name: failover dag: tasks: - name: mark-from-inactive template: set-status arguments: parameters: - name: cluster-name value: "{{workflow.parameters.from-cluster-name}}" - name: status value: inactive - name: mark-to-active dependencies: [mark-from-inactive] template: set-status arguments: parameters: - name: cluster-name value: "{{workflow.parameters.to-cluster-name}}" - name: status value: active - name: set-status inputs: parameters: - name: cluster-name - name: status container: image: pipekit13/cli env: - name: PIPEKIT_USERNAME valueFrom: secretKeyRef: name: pipekit-credentials key: username - name: PIPEKIT_PASSWORD valueFrom: secretKeyRef: name: pipekit-credentials key: password command: [sh, -c] args: - | pipekit login pipekit update cluster {{inputs.parameters.cluster-name}} --status={{inputs.parameters.status}} ``` Submit the workflow to the ops cluster from any environment that has the Pipekit CLI. ```bash pipekit submit failover.yaml --cluster-name ops \ -p from-cluster-name= \ -p to-cluster-name= ``` The same workflow handles the reverse direction when invoked with the cluster names swapped. Wrapping it in a Pipe with a webhook or schedule, or invoking it from Azure DevOps, GitHub Actions, or GitLab CI, are all variations on the same shape. ## Failing back When the primary region recovers and its Pipekit Agent reports a green indicator in the `Clusters` view, run the reverse sequence. 1. Confirm the primary cluster's Agent is connected. 2. Run `pipekit update cluster --status=active`, then `pipekit update cluster --status=inactive`. Reactivating the primary triggers Pipekit's queue cleanup: any workflow, action, or lint messages that were queued for the primary before the failover are dropped, not replayed. 3. Switch `--cluster-name` back to the primary cluster's name in every submission job. Runs that completed on the secondary cluster during the outage remain in its run history. There is no need to migrate them; they stay associated with the cluster that executed them. # Operating at Scale Configuration to scale Pipekit beyond defaults The pages here cover configuration you should turn on once Pipekit's defaults stop holding up. The defaults are tuned for small to moderate deployments; heavy concurrent throughput or very large workflows will push past them. ## When to read these pages * [Vector Log Collection](/using-pipekit/operating-at-scale/vector-log-collection). Read this if you are losing logs, or if log streaming is putting load on your Kubernetes API server. * [Node Status Offloading](/using-pipekit/operating-at-scale/node-status-offloading). Read this if you are running workflows large enough that Argo Workflows itself has node status offloading enabled. ## Related For region-level continuity across separate clusters, see [Disaster Recovery](/using-pipekit/clusters/disaster-recovery). # Vector Log Collection ## Why Vector The Pipekit Agent's built-in log transport is best-effort. It streams logs from each workflow pod via the Kubernetes API and forwards them to Pipekit. There is no write-ahead log and no retry. If shipment fails, those logs are gone. Two failure modes follow. *Log loss under API server pressure.* The agent reads logs through the Kubernetes API. Any sustained load on the API server can stall its log streams. Without a replay path, the agent does not recover those logs. *Etcd cost at scale.* Streaming every container of every workflow pod through the Kubernetes API loads etcd. For workflows with many parallel pods, that pressure sets a practical ceiling on how big a Pipekit deployment can grow before the API server becomes the bottleneck. Vector addresses both. It runs as a DaemonSet on every node and reads container logs directly from the node filesystem, never touching the Kubernetes API for log content. Vector buffers undelivered logs to disk (default 500 MB per node) and retries with backoff. Transient ingest failures no longer mean lost data. The built-in agent path is fine at small scale. Switch to Vector once log loss or API-server load becomes a real concern. ## How it works The Pipekit Agent Helm chart includes [Vector](https://vector.dev) as an optional subchart, gated on `vector.enabled`. When enabled, the chart deploys Vector as a DaemonSet with a ConfigMap that defines the full log pipeline. Vector's `kubernetes_logs` source reads container log files directly from each node, filtered to pods carrying the `workflows.argoproj.io/workflow` label so the source picks up only Argo Workflow pods. A VRL transform extracts the Pipekit identifiers (`orgUUID`, `runUUID`, `pipeUUID`) from pod labels, the Argo workflow node ID from the `workflows.argoproj.io/node-id` pod annotation, and the pod name, container name, and log timestamp from Kubernetes metadata. A filter drops any record missing a required field. A final transform reshapes the remaining records to the field set the Pipekit messenger expects. The HTTP sink batches up to 1024 events per request with a 1-second flush. It POSTs each batch to `{messengerBaseUri}/api/messenger/v1/logs/ingest/batch`, authenticated with `X-PIPEKIT-API-KEY`. A 500 MB on-disk buffer sits behind the sink: Vector retries delivery with backoff, and when the buffer fills, producers block rather than drop events. ## Enabling Vector Set `vector.enabled=true` and disable the agent's built-in log path with `configMap.sendLogsToPipekit=false`: ```bash helm upgrade -i -n argo \ pipekit-agent pipekit/pipekit-agent \ --set secrets.pipekitSecretAccessKey="[provided Secret Access Key]" \ --set secrets.pipekitClusterId="[provided Cluster ID]" \ --set vector.enabled=true \ --set configMap.sendLogsToPipekit=false ``` {% hint style="info" %} When `vector.enabled=true`, the chart ignores `configMap.sendLogsToPipekit` and disables the agent's built-in log path. Set the flag to `false` anyway for hygiene, so your values match your intent. {% endhint %} ## Self-hosted Pipekit If you run a self-hosted Pipekit instance and have set `configMap.messengerBaseUri` to your own messenger URL, the chart automatically threads that value into Vector's HTTP sink. You do not need to configure the URL on the Vector side. ## Image pull secrets If you mirror container images into a private registry, set `vector.image.pullSecrets` to a list of secret references the same way you would for the agent itself: ```yaml vector: enabled: true image: pullSecrets: - name: my-registry-credentials ``` ## Authenticating Vector via an existing Secret When you configure the agent with `secrets.existingSecret`, Vector does not automatically inherit those credentials. Vector lives in the subchart, so you must tell it explicitly to read from the secret using `vector.envFrom`: ```yaml secrets: existingSecret: pipekit-agent vector: enabled: true envFrom: - secretRef: name: pipekit-agent ``` If you pass `secrets.pipekitSecretAccessKey` inline rather than using an existing secret, you do not need `envFrom`. ## Resources and tuning Default Vector resources are conservative: ```yaml vector: resources: requests: cpu: 30m memory: 130Mi ``` These defaults are enough for moderate log volume. For clusters running many large parallel workflows, increase CPU and memory. See [Vector's sizing guidance](https://vector.dev/docs/setup/going-to-prod/sizing/) for tuning under heavy load. ## Verifying it's working 1. Confirm the DaemonSet is Ready on every node: ```bash kubectl -n argo get ds ``` 2. Port-forward to one Vector pod and check its local API on `127.0.0.1:8686`: ```bash kubectl -n argo port-forward ds/pipekit-agent-vector 8686:8686 curl localhost:8686/health ``` 3. Run a workflow and confirm its logs appear in the Pipekit UI. ## Reference For the full set of Vector-related Helm values, see the values table in [Pipekit Agent Helm Chart](/reference/helm-values/agent). The relevant rows are `vector.enabled`, `vector.dataDir`, `vector.envFrom`, `vector.existingConfigMaps`, `vector.image.pullSecrets`, `vector.resources`, `vector.role`, and `vector.service.enabled`. # Node Status Offloading ## Why offloading exists Argo Workflows stores the status of every node in a workflow inside the Workflow custom resource. For workflows with thousands of nodes, or workflows whose nodes carry large outputs, that status payload can exceed the 1 MiB per-object size limit. Argo enforces this limit to stay within etcd's request limit. When the payload exceeds it, Argo first compresses node status into the CR. If the compressed payload still does not fit and you have not configured offloading, the workflow may be stuck its previously 1 MiB compliant state. Argo's solution is *node status offloading*. When the node status would grow too large, Argo writes it to an external SQL database (PostgreSQL or MySQL) and keeps only a pointer in the Workflow CR. This lifts the etcd ceiling and is required for very large workflows. For the upstream rationale and Argo-side configuration, see [Offloading large workflows](https://argo-workflows.readthedocs.io/en/latest/offloading-large-workflows/) in the Argo Workflows documentation. ## Why the Pipekit Agent needs to know The Pipekit Agent watches Argo workflows and forwards their state to Pipekit so runs are visible in the UI. When offloading is enabled, the Workflow CR no longer contains full node status. The node status field holds only a pointer to the offloading database. An agent that does not know about offloading reads only the pointer, not the actual node-level data. Your Pipekit UI then shows incomplete or empty workflow graphs for any offloaded workflow. Configure `features.workflows.nodeOffloading` on the agent with credentials for the same database Argo offloads to. The agent then reads node status directly when the CR is incomplete. ## Prerequisites {% hint style="info" %} Configure Argo Workflows for offloading first, then point the agent at the same database. The agent reads from the offloading database; it does not create the schema or turn offloading on for you. {% endhint %} Follow the upstream [Argo offloading guide](https://argo-workflows.readthedocs.io/en/latest/offloading-large-workflows/) to enable offloading on your Argo Workflows installation. ## Enabling offloading on the agent Set `features.workflows.nodeOffloading.enabled=true` and provide the database connection details. A minimal Helm install for PostgreSQL with inline credentials: ```bash helm upgrade -i -n argo \ pipekit-agent pipekit/pipekit-agent \ --set secrets.pipekitSecretAccessKey="[provided Secret Access Key]" \ --set secrets.pipekitClusterId="[provided Cluster ID]" \ --set features.workflows.nodeOffloading.enabled=true \ --set features.workflows.nodeOffloading.argoDB.driver=postgres \ --set features.workflows.nodeOffloading.argoDB.host=argo-db.example.com \ --set features.workflows.nodeOffloading.argoDB.port=5432 \ --set features.workflows.nodeOffloading.argoDB.database=argo \ --set features.workflows.nodeOffloading.argoDB.secret.argoDBUsername=argo \ --set features.workflows.nodeOffloading.argoDB.secret.argoDBPassword='[password]' ``` For real deployments, use a values file rather than a long chain of `--set` flags. ## Table names must match Argo The agent reads from two tables: `argo_workflows` (offloaded node status) and `argo_archived_workflows` (archived workflows). These names match Argo Workflows' defaults, and you should not need to change them. If you have customized the table names in your Argo Workflows configuration, set the same values on the agent: ```yaml features: workflows: nodeOffloading: enabled: true argoDB: offloadedNodesTableName: argo_workflows archiveTableName: argo_archived_workflows ``` {% hint style="info" %} A mismatch here causes the agent to log database errors and serve workflows with empty node status until you correct the names. {% endhint %} ## Database driver The agent supports both PostgreSQL and MySQL. Set `features.workflows.nodeOffloading.argoDB.driver` to `postgres` or `mysql`. The default port is 5432. If you set `driver: mysql`, set `port` explicitly to your MySQL port (typically 3306). The chart does not adjust the default port when the driver changes. The driver must match the database Argo Workflows is offloading to. ## Secrets: inline vs. existing Inline credentials are suitable for development: ```yaml features: workflows: nodeOffloading: enabled: true argoDB: host: argo-db.example.com database: argo secret: argoDBUsername: argo argoDBPassword: '[password]' ``` For production, reference an existing Secret: ```yaml features: workflows: nodeOffloading: enabled: true argoDB: host: argo-db.example.com database: argo secret: existingSecret: argo-db-credentials ``` The referenced Secret must contain the data keys `ARGO_DB_USERNAME` and `ARGO_DB_PASSWORD`: ```bash kubectl -n argo create secret generic argo-db-credentials \ --from-literal=ARGO_DB_USERNAME='argo' \ --from-literal=ARGO_DB_PASSWORD='[password]' ``` Use single quotes to escape special characters such as `$`, `\`, `*`, and `!` in your password. Without them, your shell interprets these characters before kubectl creates the secret. ## TLS For PostgreSQL connections, set `features.workflows.nodeOffloading.argoDB.sslMode` to one of `disable`, `allow`, `prefer`, `require`, `verify-ca`, or `verify-full`. The default is `disable`, which is only appropriate for development. For production, use `require` at minimum, and `verify-full` if you have CA certificates available. The agent ignores this setting for MySQL. ## Connection pool tuning The defaults are reasonable for moderate load: | Setting | Default | When to change | | ----------------------- | ----------- | ------------------------------------------------------------------------------------- | | `maxOpenConnections` | 30 | Increase if the agent serves many concurrent UI requests against offloaded workflows. | | `maxIdleConnections` | 15 | Keep at roughly half of `maxOpenConnections`. | | `maxConnectionLifetime` | 5 (minutes) | Shorter values help when sitting behind connection-pool middleware such as PgBouncer. | | `maxRetries` | 3 | Raise if your database has frequent transient failures. | ## Verifying it's working 1. Check the agent logs at startup for a successful database connection. Errors at this stage usually indicate wrong credentials, wrong host or port, or `sslMode` mismatch with the database server. 2. Run a workflow large enough to trigger offloading on Argo's side, or pick an existing offloaded workflow. 3. Open the run in the Pipekit UI and confirm the run graph is fully populated rather than showing empty or stub nodes. ## Reference For the full set of `features.workflows.nodeOffloading` values, see the values table in [Pipekit Agent Helm Chart](/reference/helm-values/agent). Upstream documentation: [Argo Workflows — Offloading large workflows](https://argo-workflows.readthedocs.io/en/latest/offloading-large-workflows/). # Organizations & Access Pipekit Organization An Organization is a logical grouping of Users and their permissions. Your Organization is the top level entity in Pipekit. Users can only belong to one Organization. # Create an Organization Go to the [Org tab in Pipekit](https://pipekit.io/organization) and click on the `Create Org` button. You will be prompted to enter an organization name and a description. Once you have entered the required information, click on the `Submit` button to create your Pipekit Organization. ## Connecting your Organization to git You will then be prompted to optionally connect your Organization to your your git provider. You can choose to connect to either GitHub or Gitlab. Connecting your Organization to git allows your users: * to create Pipes from workflow manifests stored in your git repositories; * to trigger pipe runs based on git events; * to submit and manage workflowTemplates via Pipekit. You can choose to add all your repositories or specific repositories to your Pipekit Organization. ### GitHub 1. Click the button for GitHub. It will lead you through the process to authorize Pipekit's GitHub App. 2. When prompted by GitHub, select either, "All repositories" or select the list of repositories you would like to grant Pipekit access to using the dropdown. 3. Click, "Authorize" ### Gitlab For Gitlab, you will need to create a [Personal Access Token](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html). We recommend creating a service account user in your organization on Gitlab that has access to any repositories that you want Pipekit to read from. To connect Pipekit, click the button for Gitlab, input the Personal Access Token that you created, optionally change the Gitlab URL and click, "Submit" ### BitBucket For BitBucket, you will need a [HTTP Access Token](https://confluence.atlassian.com/bitbucketserver/http-access-tokens-939515499.html). You will need to create an access token with "PROJECT\_READ" and "REPO\_ADMIN" values. To connect Pipekit, click the button for BitBucket Data Center, input the access token and the URL to your BitBucket Data Center installation endpoint, then click "Submit". ### Azure DevOps Azure DevOps Services (`dev.azure.com/{org}`) is supported via a Personal Access Token. Create a PAT with these scopes: Code (Read, Write, & Status) and Project & Team (Read). The PAT owner must be a Project Administrator — or have the [Edit subscriptions](https://learn.microsoft.com/en-us/azure/devops/service-hooks/view-permission?view=azure-devops) project permission — so Pipekit can register [Service Hook](https://learn.microsoft.com/en-us/azure/devops/service-hooks/overview?view=azure-devops) subscriptions. There is no longer a standalone "Service Hooks" PAT scope; Microsoft has made `vso.hooks*` [private](https://learn.microsoft.com/en-us/azure/devops/integrate/get-started/authentication/oauth?view=azure-devops), so the project-level permission is the gating mechanism. To connect Pipekit, click the button for Azure DevOps, fill in the organization URL and the PAT, then click "Submit". One Pipekit account corresponds to one Azure DevOps organization; multiple projects within the organization are surfaced in the repo picker grouped by project name. See the [self-hosting guide](/self-hosting-pipekit/initial-login/git-provider#azure-devops) for the operator-side configuration that ships with each Pipekit deployment. # Members Organization members are managed on the `Org` page. The `My Account` page holds your own profile, email addresses and password, and nothing there affects other people. ## Adding users to your Organization Go to the [Org tab in Pipekit](https://pipekit.io/organization) and open `People & Access`. You will be presented with the `Users` tab. To invite additional users, enter their email address in the `Invite User` field and click on the `Invite` button. The user will receive an email with a link to join your Pipekit Organization. {% hint style="info" %} Adding an email address under `My Account` adds it to your own login. It does not invite anybody. {% endhint %} ## Managing user permissions On the Organization's `People & Access` tab, open `Users`, find the user whose permission you wish to manage and click the gear icon on the right hand side. You will be presented with a list of permissions that you can grant to the user. ## Removing users from your Organization On the Organization's `People & Access` tab, open `Users`, find the user that you wish to remove and click the gear icon on the right hand side. You will be presented with a `Remove User` button. Click on the button to remove the user from your Pipekit Organization. ## Linking Pipekit Users with Git Identities If you are using [Run/Sync Conditions](/using-pipekit/pipes/edit/run-sync-conditions) to trigger Pipe Runs, you will need to map each user's Git identity with their Pipekit identity so that Pipekit can understand and display the name of the user who triggered a [Pipe Run](/using-pipekit/runs). You can do this by navigating to the Organization's `People & Access` tab, opening `Users`, and choosing the option to `Edit Git Mapping`. Git identities of users who have recently interacted with your synced repositories will be available to map to each user. A Git identity can only be mapped to one Pipekit user. CI/robot (service) accounts are not pre-existing mapped identities. To map a CI/robot (service) account's Git identity, first create a Pipekit account for the CI/robot account, then map its Git identity. # Permissions Namespace permissions are used to control the namespaces that individual users can access in a given cluster. {% hint style="info" %} This configuration is based on the concept of GitOps, so you first need to ensure your git account is connected to your Organization. For more information, refer to the [Connecting your Organization to git](/organizations-and-access/create#connecting-your-organization-to-git) documentation. {% endhint %} ## Configuration file You will need to create a configuration file to define the namespace permissions you require for your Organization. The configuration file should be stored in a git repository that is connected to your Organization. Configuration file is a yaml file that defines namespace permission configuration. It has the following fields: * `username` field is username/email * `clusterName` field is name of the cluster from organization * `namespace` field is name of the Kubernetes namespace that user can access. Wildcard operator (\*) is allowed on namespace level. ### Configuration file example ```yaml version: v1alpha1 users: - username: test-user config: - clusterName: local-cluster namespaces: - default - dev - clusterName: local-cluster-2 namespaces: - '*' - username: test-user-2 config: - clusterName: local-cluster namespaces: - default ``` ## Applying the configuration file Once your configuration file is available in git, go to the [Org tab in Pipekit](https://pipekit.io/organization) and select the `Permissions` tab. From here, you can select the repo, branch and specify configuration file location. Submitting the configuration file will trigger Pipekit to apply the defined permissions and after that moment, only the users that are specified in the configuration file will be able to access namespaces that are specified. From this point, updating the file in your git repository will trigger Pipekit to update the permissions accordingly. # Settings ## Git account settings You can use the settings tab to connect your git account to Pipekit or disconnect your github account from Pipekit. For further information on connecting your git account to Pipekit, refer to the [Connecting your Organization to git](/organizations-and-access/create#connecting-your-organization-to-git) documentation. ## Docker Registry Credentials (imagePullSecrets) Your workflows may need to pull containers from a private docker registry. By inputting the credentials for your private docker registry into the Pipekit Org, you can ensure that your workflows can pull containers from your private docker registry without you having to manually add `imagePullSecrets` and to distribute them to your namespaces and clusters. You can add multiple docker registry credentials to your Pipekit Organization You can also add multiple credentials for the same docker registry. If you wish to create credentials for Docker Hub, leave the `Server Address` field blank. At workflow runtime, [Pipekit Agent](/concepts/pipekit-agent) creates a kubernetes secret in the namespace where the workflow is running. The secret is of type `kubernetes.io/dockerconfigjson` and starts with the username entered in the credentials field. The workflow then references this secret to pull images. When the workflow completes, the secret is deleted. ## Organization Info You can rename the organization and modify the description of the organization here. ## AI Assistant A checkbox on this page enables the [AI Assistant](https://github.com/pipekit/pipeline-mono/tree/gitbook/docs/ai/in-app-assistant/README.md) sidebar for everyone in the organization. It is **off by default**. When the checkbox is off, members of the organization see no AI Assistant entry point in the navbar. Their per-user LLM configuration is preserved but inactive. Turning the checkbox on does not change individual users' configuration — each member still needs to configure their own LLM endpoint and API key under their personal settings before they can use the assistant. Only organization admins can change this setting. # Alert Providers Pipekit Workflow Alerting lets you configure alerts for workflows through Slack or MS Teams integration. You can set alerts on specific workflow statuses such as QUEUED, RUNNING, FAILED or COMPLETED. To configure alerts for a workflow, your Pipekit organization needs to be connected to either Slack or MS Teams. Once you have connected an alert provider, you can add alerts for specific workflows. ## Slack and Teams Applications The alerts are delivered using applications that you must install into your Slack or Teams workspace. This requires a Slack/Teams administer to perform the installation and to connect the application to your Pipekit organization. ## Connect an Alert Provider Go to the [Org tab in Pipekit](https://pipekit.io/organization). Then navigate to the `Alert Providers` tab. Select either Slack or MS Teams, and follow the on-screen prompts to connect your Pipekit Organization to your Slack or MS Teams workspace. You can repeat the process for either multiple channels, workspaces or providers. For more information on setting up alerts, view the [Pipekit Alerting](/using-pipekit/pipes/edit/alerting) documentation. ## Delete an Alert Provider Go to the [Org tab in Pipekit](https://pipekit.io/organization). Then navigate to the `Alert Providers` tab. Find the alert provider that you wish to remove, then locate and click the trash can icon to the right. # Bring Your Own Logging Pipekit BYO Logging Backend lets you collect and view workflow logs in a self-hosted Loki backend. This allows you to have the full logging experience managed by Pipekit without having Pipekit ever ac Pipekit allows you to connect your self-hosted Loki instance to the Pipekit control plane. Once you add your Loki configuration to Pipekit, you will have to use a log collector on your Kubernetes clusters in order to send the logs from your cluster to your Loki instance. ## Connect a Loki Instance Go to the [Org tab in Pipekit](https://pipekit.io/organization). Then navigate to the `BYO Logs` tab. Enter the address of your Loki instance along with a username and password that you use for authenticating at the gateway/ingress layer. Then submit the information. You'll have to make sure that the address is accessible to the Internet and that the following endpoints are reachable: ```yaml /loki/api/v1/query /loki/api/v1/query_range /loki/api/v1/tail /loki/api/v1/series ``` ## Configuring a Log Collector In order to get the logs from your Kubernetes clusters running Argo Workflows into your Loki instance, you'll have to configure a log collector. We use and test with [Fluent Bit](https://fluentbit.io/). ### Labels Pipekit appends three labels to pods run by workflows on clusters where the Pipekit agent is present and configured to either submit workflows or read externally submitted workflows. This works for both Pipekit-submitted and externally submitted workflows. The labels are the following: ```yaml workflows.pipekit.io/org_uuid workflows.pipekit.io/pipe_uuid workflows.pipekit.io/run_uuid ``` Map these to `orgUUID`, `pipeUUID`, and `runUUID` in Loki. Pipekit also reads three more labels that your log collector must set on each log stream: `nodeId`, `podName`, and `containerName`. `podName` is the name of the pod and `containerName` is the name of the container. `nodeId` is the Argo workflow node ID. Argo sets this ID on each pod as the `workflows.argoproj.io/node-id` annotation, so read the value from that annotation. {% hint style="warning" %} `nodeId` must hold the Argo workflow node ID, not the name of the Kubernetes cluster node that the pod ran on. Pipekit matches logs to a workflow step by `nodeId`. If you map it to the cluster node name, the logs for that step do not appear in Pipekit. {% endhint %} ### Fluent Bit Config Here's a sample fluent bit config that we'd recommend. Note that this configuration reads logs directly from the container file system: ```yaml apiVersion: v1 kind: ConfigMap metadata: name: fluentbit-config namespace: <> data: fluent-bit.conf: | [SERVICE] Flush 1 Log_Level info Daemon off Parsers_File parsers.conf @INCLUDE input.conf @INCLUDE output.conf input.conf: | [INPUT] Name tail Parser json Path /tmp/*.log # set to whatever path your logs will be stored in the filesystem Mem_Buf_Limit 100MB Skip_Long_Lines On Refresh_Interval 5 Rotate_Wait 15 output.conf: | [OUTPUT] name loki match * host <> port <> labels orgUUID=$orgUUID, pipeUUID=$pipeUUID, runUUID=$runUUID, podName=$podName, containerName=$containerName, nodeId=$nodeId tenant_id_key orgUUID # this line is only needed if you're doing multi-tenancy remove_keys orgUUID, pipeUUID, runUUID, podName, containerName, createdAt, nodeId line_format key_value # must be set to key_value, otherwise character escapes will appear drop_single_key on parsers.conf: | [PARSER] Name json Format json ``` # SSO When you first sign up to Pipekit, you can choose to authenticate using various social providers, with your email address or a username and password combination. ## SSO (SAML and SCIM) After creating your Pipekit account, you have the option of converting your Pipekit Organization to use SSO. This will allow members of your organization to authenticate with your chosen Identity Provider (IdP) and will prevent them from logging in with alternative methods. An Organization can register more than one email domain, so members with addresses on different domains can sign in through the same Identity Provider. ### Supported Identity Providers * [Microsoft Entra](/organizations-and-access/sso/entra) * [Okta](/organizations-and-access/sso/okta) ### Planned Identity Providers * Google Workspace # Entra After logging in to your Pipekit account, you can enable SSO for your Organization. This will allow members of your Organization to authenticate with Microsoft Entra and will prevent them from using alternative authentication methods. {% hint style="warning" %} Warning: Enabling Microsoft Entra SSO will prevent users in your Organization from being able to log in using alternative methods (for example username/password or a social login). {% endhint %} ## Setting up Microsoft Entra with Pipekit (SAML) * Firstly setup an "Enterprise Application in Entra" * Navigate to "Enterprise apps" * Click "New application" * Click "Create your own application". * Name it whatever you'd like, although something recognizable is recommended and select "Integrate any other application you don't find in the gallery (Non-gallery)". * Click "Create" * Secondly setup SAML auth in your application * Navigate to your application * Select "Single sign-on" * Click on "SAML" * We now move on to Pipekit to continue the process, but keep this tab open. * Navigate to your Org and click on "Identity Providers". * Select "Add Microsoft Entra Provider" * Enter the domain you use to authenticate with. * If your Organization uses more than one email domain, click "Add another Domain" and enter the others. All domains must be verified domains in the same Entra tenant, because one Enterprise Application serves all of them. * Click "Add Provider". * Navigate back to Entra in order to paste these two URLS under the "Basic SAML Configuration" box. * While in the Entra tab, copy the URL from under "SAML Certificates", labelled "App Federation Metadata URL". * After navigating to Pipekit, click next and paste in this URL and hit submit. * Finally, we can navigate back to Microsoft Entra to setup the Attributes & Claims. * In "Single sign-on", after SAML has been configured you should see an "Attributes & Claims" block, click the edit button on this block. * Required claim | Claim name | Type | Value | | ---------------------------------- | ---- | ----------------------------------------- | | `Unique User Identifier (Name ID)` | SAML | `user.mail [nameid-format: EmailAddress]` | * Additional claims | Claim name | Type | Value | | -------------------------------------------------------------------- | ---- | ------------------------ | | `email` | SAML | `user.mail` | | `firstName` | SAML | `user.givenname` | | `http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress` | SAML | `user.mail` | | `http://schemas.xmlsoap.org/ws/2005/05/identity/claims/givenname` | SAML | `user.givenname` | | `http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name` | SAML | `user.userprincipalname` | | `http://schemas.xmlsoap.org/ws/2005/05/identity/claims/surname` | SAML | `user.surname` | | `lastName` | SAML | `user.surname` | ## Managing domains You can change which email domains authenticate with Microsoft Entra after setup. * Navigate to your Org and click on "Identity Providers". * Your configured domains are listed under "Domains". * Click "Add Domain" to allow another email domain. * Click the X on a domain to remove it. You cannot remove the last remaining domain. {% hint style="warning" %} Warning: Removing a domain prevents users with email addresses on that domain from logging in. {% endhint %} ## Microsoft Entra Group Sync (SCIM) {% hint style="warning" %} Warning: All groups are given Admin permission in Pipekit by default. This is to ensure that you still have the required permissions to manage your organization. If you want to change the permission level, you can do so after the group has been created in Pipekit. {% endhint %} {% hint style="warning" %} Warning: SCIM support for Entra is minimal, it supports the basic reference spec but doesn't support any extensions. Contact us through your Slack support channel or email `hello@pipekit.io` if you need additional functionality. {% endhint %} * Navigate to the Groups tab under your Organization in Pipekit. * Click "Configure SCIM". * Copy the "SCIM Endpoint URL" for later. * Click "Generate SCIM token" * Navigate to your Enterprise App in Microsoft Entra * Click "Provisioning" * Under "Create Configuration", click "Connect your application" * Paste in the URL you copied earlier. * Navigate back to Pipekit to copy in the token. * Click "Test Connection" * When the tests pass, you should be able to click "Create" # Okta After logging in to your Pipekit account, you can enable SSO for your Organization. This will allow members of your Organization to authenticate with Okta and will prevent them from using alternative authentication methods. {% hint style="warning" %} Warning: Enabling Okta SSO will prevent users in your Organization from being able to log in using alternative methods (for example username/password or a social login). {% endhint %} ## Setting up Okta with Pipekit (SAML) * Navigate to your Org and click on "Identity Providers". * Select "Add Okta Provider". * Enter the domain you use to authenticate with. This is typically the domain you use for your Organization's email addresses. * If your Organization uses more than one email domain, click "Add another Domain" and enter the others. All domains must belong to users in the same Okta organization. * Click "Add Provider" * You will then be provided with some unique URLs that you need to add to an Okta application. * Navigate to your Okta Admin Dashboard and create a new app integration under the Applications menu. * Choose `SAML 2.0` and click "Next". * Under "General Settings", type an appropriate App Name, we recommend "Pipekit". * You can add [a logo](https://pipekit.io/Pipekit-icon-sq-520x520.png) if you wish. * Click "Next". * Under "SAML Settings", enter the following: * Single sign on URL: The `Single sign-on URL (ACS)` provided by Pipekit. * Ensure "Use this for Recipient URL and Destination URL" is checked. * Audience URI: The `Audience URI (SP Entity ID)` provided by Pipekit. * Set the following attribute statements: * `firstName` -> Name format: Basic -> `user.firstName` * `lastName`-> Name format: Basic -> `user.lastName` * `email` -> Name format: Basic -> `user.email` * Click "Next" and click "Finish". * Copy the Metadata URL from the "Sign On" tab. * Go back to Pipekit and paste the Metadata URL into the "Metadata URL" field on the next screen. * Alternatively, you can expand the "More Details" dropdown in the "Sign On" tab to reveal the values required for the "Try another way" option in Pipekit. * Copy the Sign on URL, Issuer and Certificate values into their respective fields in Pipekit. * Click "Submit". ## Okta Group Sync (SCIM) Pipekit supports SCIM for syncing groups from Okta. * Navigate to the Groups tab under your Organization in Pipekit. * Click "Configure SCIM". * Copy the "SCIM Endpoint URL" for later. * In Okta, edit the app settings of your Pipekit Application under the General tab. * Enable SCIM provisioning and save. * Go to the Provisioning tab and paste the SCIM Endpoint URL into the SCIM Connector Base URL field. * On the same screen, set the Unique Identifier Field for Users to `email`. * On the same screen, check the following under Supported Provisioning Actions: * Push New Users * Push Profile Updates * Push Groups * On the same screen, set the authentication mode to "HTTP Header". * Generate a new SCIM token in Pipekit and copy it. * Go back to Okta and enter the SCIM token you generated into the Authorization header field. * Test the connection and save. ### Provisioning Settings * Go to the Provisioning tab in Okta and go to Provisioning to App. Click Edit. * Enable the following and then save: * Create Users * Update User Attributes * Deactivate Users ## Assigning Groups Follow the [Okta Documentation](https://help.okta.com/en-us/content/topics/users-groups-profiles/app-assignments-group-push.htm) to assign both push group(s) and assignment group(s) or users to the Pipekit application to push groups and users respectively. {% hint style="warning" %} Warning: All groups are given Admin permission in Pipekit by default. This is to ensure that you still have the required permissions to manage your organization. If you want to change the permission level, you can do so after the group has been created in Pipekit. {% endhint %} * Wait for the push group status to change from `Pushing` to `Active`. * Navigate back to Pipekit and refresh the Groups tab. You should now see your group from Okta. * You can change the permission level by clicking on the cog on the group and selecting a different permission level. * In the Users tab, you should see the users from your Okta group. ## Managing domains You can change which email domains authenticate with Okta after setup. * Navigate to your Org and click on "Identity Providers". * Your configured domains are listed under "Domains". * Click "Add Domain" to allow another email domain. * Click the X on a domain to remove it. You cannot remove the last remaining domain. {% hint style="warning" %} Warning: Removing a domain prevents users with email addresses on that domain from logging in. {% endhint %} ## Deleting your Okta Provider If you wish to disconnect Pipekit from Okta: * Navigate to your Org and click on "Identity Providers". * Click on `Delete Okta Provider` and confirm. Disconnecting Okta will prevent any users in your Organization from logging in using Okta. This may include your own user. Contact Pipekit support if you need help with this. # Self-Hosting Pipekit How to use the self-hosted version of Pipekit Pipekit can be installed in an entirely self-hosted manner. This means that you can run Pipekit on your own infrastructure, without relying on Pipekit's cloud service. The installation is designed with air-gapping in mind. However, Pipekit needs to integrate with your Kubernetes cluster(s) running Argo Workflows, and many of the features of Pipekit rely on being able to access a git provider. To self-host Pipekit, contact us at or via your Pipekit Slack support channel. # Evaluate Self-Hosted Spin up a self-hosted Pipekit deployment on a dev cluster in 30 minutes. A 30-minute path to a working Self-Hosted Pipekit on a local Kubernetes cluster. The goal is to let you click around the UI, run a sample workflow, and decide if Self-Hosted is the right shape for you. It does not set up a production install. For a production deploy, follow [Deploy to Production](/self-hosting-pipekit/dependencies) instead. ## Prerequisites * `kubectl`, `helm` (v3), and `docker` installed locally. * A local Kubernetes cluster (`k3d`, `kind`, `minikube`, or Docker Desktop Kubernetes all work). This guide uses `k3d`. * A Pipekit license key for the trial. Email if you don't have one; we'll send you a 30-day trial key. * Access to the `pipekitprivate` container registry on Docker Hub. Email if you don't have access; we'll set it up. ## 1. Spin up a local cluster ```bash k3d cluster create pipekit-eval \ --port "30000:30000@loadbalancer" \ --port "30001:30001@loadbalancer" ``` This gives you a single-node cluster reachable via `kubectl`. For other local cluster tools, the install steps are identical. Only the cluster-creation command changes. ## 2. Install Argo Workflows Pipekit runs on top of Argo Workflows; install it first. ```bash kubectl create namespace argo kubectl apply -n argo -f https://github.com/argoproj/argo-workflows/releases/latest/download/quick-start-minimal.yaml ``` Wait for the Argo pods to be Ready: ```bash kubectl get pods -n argo -w ``` ## 3. Pull Pipekit container images The Self-Hosted install uses private images from the `pipekitprivate` Docker Hub registry. ```bash docker login -u kubectl create namespace pipekit kubectl create secret docker-registry regcred \ --docker-username= \ --docker-password= \ --namespace=pipekit ``` For the full image list, see [Container Images](/self-hosting-pipekit/dependencies/container-images). ## 4. Install the Pipekit Helm chart ```bash helm repo add pipekit https://helm.pipekit.io helm repo update helm install pipekit pipekit/pipekit \ --namespace=pipekit \ --set global.deployType=dev \ --set license.key="" \ --set imagePullSecrets[0].name=regcred ``` This deploys the Pipekit UI, API, Pipekit Agent, ID service, and Postgres into the `pipekit` namespace. For the full values reference, see [Reference > Helm Chart Values > Self-Hosted Chart](/reference/helm-values/self-hosted). ## 5. Wait for everything to be Ready ```bash kubectl get pods -n pipekit -w ``` This takes 3 to 5 minutes on a fresh cluster. Postgres and the Pipekit services need to come up in order. ## 6. Log in with the break-glass account The first install creates a single Org Admin account with a randomly generated password printed to the install logs. You can also fetch it from the cluster: ```bash kubectl get secret -n pipekit pipekit-break-glass -o jsonpath='{.data.password}' | base64 -d echo ``` Browse to and sign in as `admin@pipekit.local` with that password. For the full break-glass setup, see [Configure > Initial Login & Break-Glass](/self-hosting-pipekit/initial-login). ## 7. Submit a sample workflow In a separate terminal: ```bash brew install pipekit/tap/cli pipekit login --host=http://localhost:30000 git clone https://github.com/pipekit/examples.git cd examples pipekit submit --cluster-name=default examples/dag-diamond/workflow.yaml ``` Open the Run in the UI and confirm logs and the Run graph render correctly. ## What's next * **Production install**: replace `deployType=dev` with `prod`, set up real ingress, point at a managed Postgres, configure backups. Follow [Deploy to Production](/self-hosting-pipekit/dependencies). * **Configure SSO**: wire your identity provider in. See [Configure > SSO](/self-hosting-pipekit/initial-login/sso). * **Connect a Git provider**: let users trigger Workflows from commits and pull requests. See [Configure > Git Provider](/self-hosting-pipekit/initial-login/git-provider). * **Right-size resources**: the `dev` profile is too small for real workloads. Bump replica counts, resource requests, and HPA limits via Helm values. ## Tearing down ```bash helm uninstall pipekit -n pipekit kubectl delete namespace pipekit k3d cluster delete pipekit-eval ``` # Deploy to Production Pre-requisites for self-hosting Pipekit Pipekit depends on the following tools being available in your environment: ## Kubernetes * We recommend Kubernetes 1.33 or greater. ### Setup * The installation makes use of ingresses to route traffic to the various services. You will need to have an ingress controller installed in your cluster. We recommend using the [ingress-nginx](https://kubernetes.github.io/ingress-nginx/) controller. * OTEL or Prometheus will allow you to monitor the pipekit services on their defined metrics ports. This is not a strict requirement but is recommended. * An in-cluster log collection tool such as Fluentd and an aggregation tool (e.g. Loki) is recommended to collect and display logs from the various services. This is not a strict requirement but is recommended. * The Pipekit services make use of HPAs to scale under load. You will need to have the metrics server installed in your cluster in order to make use of this. ## Postgres * We recommend you use a managed Postgres service such as AWS RDS or Azure Postgres. * We recommend Postgres 18 or greater. ### Setup * The Pipekit services require a Postgres database to store their data. You will need to create a database and user for the `id` and `users` services to use: ```bash CREATE DATABASE users; CREATE DATABASE id; ``` ## Redis * Can be inside the cluster or a managed service such as AWS Elasticache. Internally, we use Valkey as a Redis compatible database. * We recommend Redis or Valkey 8 or greater running in a high availability setup with sentinel. * We recommend configuring disk persistence for Redis. However, there is no need to back up this disk. If the data is lost, Pipekit will recreate it, but in-flight workflows may not have the correct state in Pipekit if Redis' data is lost at the time the workflow is being processed. ### Setup No special configuration is required for Redis. We would recommend that it is configured to be highly available. It would also be advisable to configure Redis to use a password which can be passed to the Pipekit Helm Chart. ## Grafana Loki * Can be hosted within the Kubernetes cluster, or externally. * We recommend Loki 3.5 or greater. ### Setup No special configuration is required for Loki. We would recommend that it is configured to be highly available. ## Git Provider (GitHub, GitLab) You can optionally connect your Git provider to Pipekit in order to make use of the GitOps features. While this is optional, it is highly recommended. ### Setup Follow the instructions in the [Git Provider](/self-hosting-pipekit/initial-login/git-provider) documentation to connect your Git provider to Pipekit. # Container Images Container Images The Pipekit installation consists of several container images, each of which is responsible for a different part of the Pipekit service. This page documents the images and their respective repository: | Image Repository | Image Name | Public or Private? | Required? | Reason image is optional | | ---------------- | -------------- | ------------------ | --------- | --------------------------------------------------------------------------------------------------------------- | | pipekit13 | cli | Public | No | [Used for accessing the Pipekit CLI in a container](/reference/cli#docker-container) | | pipekit13 | pipekit-agent | Public | Yes | | | pipekitprivate | events-handler | Private | No | Only required if you [integrate Pipekit with a git provider](/self-hosting-pipekit/initial-login/git-provider). | | pipekitprivate | id | Private | Yes | | | pipekitprivate | messenger | Private | Yes | | | pipekitprivate | pipekit-init | Private | Yes | | | pipekitprivate | ui | Private | Yes | | | pipekitprivate | users | Private | Yes | | In addition to the images listed above, the Pipekit installation also requires the following third-party image: | Image Repository | Image Name | Public or Private? | Required? | | ---------------- | ---------- | ------------------ | --------- | | fluent | fluent-bit | Public | Yes | There may be additional images required for the installation, depending on how you choose to configure your [third party dependencies](/self-hosting-pipekit/dependencies). ## Private Images You will require a Docker Hub account with access to the `pipekitprivate` repository to pull the private images. This will be provided to you as part of your Pipekit subscription. Contact us at for more information. You will be permitted to attach a single Docker Hub account to the `pipekitprivate` repository. We recommend that you use this account to pull the images onto your own managed repository. ## Non Root Users All of the Pipekit container images use a non-root user by default. # Kubernetes Permissions Kubernetes Permissions The Pipekit Helm Chart will create two ServiceAccounts in the namespace you install Pipekit into. These ServiceAccounts are used to control the permissions of the various components of Pipekit. ## pipekit The primary ServiceAccount is called `pipekit` by default. This can be changed by setting `global.serviceAccount.name` in the Helm Chart values. This ServiceAccount is used by the Pipekit services to interact with the Kubernetes API. This ServiceAccount is given no extra permissions by default because it does not require them. ## pipekit-job A secondary ServiceAccount is created, called `pipekit-job` by default. The `pipekit` element of the name can be changed by setting `global.serviceAccount.name` in the Helm Chart values. This ServiceAccount is used by the pipekit-init kubernetes job that sets up and rotates various passwords used by the Pipekit services. This ServiceAccount is given the following permissions: ```yaml # Manage the creation of Kubernetes Secrets to store the various passwords created by the pipekit-init Kubernetes Job. - apiGroups: - "" resources: - secrets verbs: - get - patch - create # When the pipekit-init job is run, it will create a new secret to store the various passwords. This secret is then mounted into the various Pipekit services as a volume. This permission is required to allow the pipekit-init job to restart the `id` and `users` services after the secret has been created or changed so that we can ensure the new passwords are used by those services - apiGroups: - "apps" resources: - deployments verbs: - get - patch ``` ## Pipekit-Agent The Pipekit-Agent is a separate component that is used to interact with your Argo installations. The permissions for this component are documented in the [Pipekit-Agent documentation](/reference/helm-values/agent#pipekit-agent-cluster-permissions). # Helm Install ## Installation 1. Create a local `myvalues.yaml` file that contains the default values. ```bash helm repo add pipekit https://helm.pipekit.io helm show values pipekit/pipekit > myvalues.yaml ``` 2. Set up the required dependencies. Information on these can be provided over your Slack support channel, or by email at . 3. Set a valid Pipekit license key in the `myvalues.yaml` file. 4. Ensure you have access to the privately-hosted images used by this chart through an appropriate imagePullSecret, or you have modified the `myvalues.yaml` file to use the your own copies of the images. 5. Modify `myvalues.yaml` to set the values for your specific installation. 6. Apply the Pipekit services to your Kubernetes cluster ```bash kubectl create ns pipekit helm upgrade -i -n pipekit \ -f myvalues.yaml \ pipekit pipekit/pipekit ``` ## Pipekit Helm Chart Values There are other optional, configurable options within the Helm Chart. These are listed below. | Key | Type | Default | Description | | --------------------------------------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | eventsHandler.hpa.enabled | bool | `false` | Enable or disable the Horizontal Pod Autoscaler for this service | | eventsHandler.hpa.maxReplicas | int | `10` | Set the maximum number of replicas for the Horizontal Pod Autoscaler | | eventsHandler.hpa.minReplicas | int | `1` | Set the minimum number of replicas for the Horizontal Pod Autoscaler | | eventsHandler.imageName | string | `"events-handler"` | Optionally override the default image name for this service | | eventsHandler.imageTag | string | `nil` | Optionally override the default image tag for this service | | eventsHandler.livenessProbe | object | `{"failureThreshold":2,"httpGet":{"path":"/api/events-handler/metrics/_health","port":8080},"initialDelaySeconds":70,"periodSeconds":5}` | Configure the liveness probe for this service | | eventsHandler.pdb.enabled | bool | `true` | Enable or disable the Pod Disruption Budget for this service | | eventsHandler.pdb.minAvailable | string | `"50%"` | Set the minimum number of pods available during a disruption | | eventsHandler.pdb.unhealthyPodEvictionPolicy | string | `"AlwaysAllow"` | Set unhealthyPodEvictionPolicy on the PDB. Options: `IfHealthyBudget` or `AlwaysAllow` | | eventsHandler.readinessProbe | object | `{"httpGet":{"path":"/api/events-handler/metrics/_health","port":8080},"periodSeconds":5}` | Configure the readiness probe for this service | | eventsHandler.resources.requests | object | `{"cpu":"20m","memory":"35Mi"}` | Set the resource requests for this service | | gatewayAPI.enabled | bool | `false` | Enable or disable the Gateway API resources for Pipekit. | | gatewayAPI.httpRoute | object | `{"annotations":{},"hostnames":[],"labels":{},"parentRefs":[],"rules":[{"backendRefs":[{"name":"id","port":8080}],"matches":[{"path":{"type":"PathPrefix","value":"/api/id"}}]},{"backendRefs":[{"name":"events-handler","port":8080}],"matches":[{"path":{"type":"PathPrefix","value":"/api/events-handler"}}]},{"backendRefs":[{"name":"messenger","port":8080}],"matches":[{"path":{"type":"PathPrefix","value":"/api/messenger"}}]},{"backendRefs":[{"name":"ui","port":80}],"matches":[{"path":{"type":"PathPrefix","value":"/"}}]},{"backendRefs":[{"name":"users","port":8080}],"matches":[{"path":{"type":"PathPrefix","value":"/api/users"}}]}]}` | Define the HTTP route for Pipekit services | | gatewayAPI.httpRoute.annotations | object | `{}` | Additional HTTPRoute annotations | | gatewayAPI.httpRoute.hostnames | list | `[]` | List of hostnames for the HTTPRoute | | gatewayAPI.httpRoute.labels | object | `{}` | Additional HTTPRoute labels | | gatewayAPI.httpRoute.parentRefs | list | `[]` | Gateway API parentRefs for the HTTPRoute # Must reference an existing Gateway | | gatewayAPI.httpRoute.rules | list | `[{"backendRefs":[{"name":"id","port":8080}],"matches":[{"path":{"type":"PathPrefix","value":"/api/id"}}]},{"backendRefs":[{"name":"events-handler","port":8080}],"matches":[{"path":{"type":"PathPrefix","value":"/api/events-handler"}}]},{"backendRefs":[{"name":"messenger","port":8080}],"matches":[{"path":{"type":"PathPrefix","value":"/api/messenger"}}]},{"backendRefs":[{"name":"ui","port":80}],"matches":[{"path":{"type":"PathPrefix","value":"/"}}]},{"backendRefs":[{"name":"users","port":8080}],"matches":[{"path":{"type":"PathPrefix","value":"/api/users"}}]}]` | HTTPRoute rules configuration | | gatewayAPI.ssoHttpRoute.enabled | bool | `false` | Enable or disable the public Gateway API resources for Pipekit. HTTP Route to publicly expose routes of the Users service for SCIM integration with SSO providers (Okta, Entra) Required if login.oktaSSO.enabled or login.entraSSO.enabled is true | | gatewayAPI.ssoHttpRoute.httpRoute | object | `{"annotations":{},"hostnames":[],"labels":{},"parentRefs":[],"rules":[{"backendRefs":[{"name":"users","port":8080}],"matches":[{"path":{"type":"RegularExpression","value":"^/api/users/v1/organizations/.+/scim/Groups(/.*)?$"}}]},{"backendRefs":[{"name":"users","port":8080}],"matches":[{"path":{"type":"RegularExpression","value":"^/api/users/v1/organizations/.+/scim/Users(/.*)?$"}}]}]}` | Define the public HTTP route for Pipekit SSO services | | gatewayAPI.ssoHttpRoute.httpRoute.annotations | object | `{}` | Additional HTTPRoute annotations | | gatewayAPI.ssoHttpRoute.httpRoute.hostnames | list | `[]` | List of hostnames for the HTTPRoute | | gatewayAPI.ssoHttpRoute.httpRoute.labels | object | `{}` | Additional HTTPRoute labels | | gatewayAPI.ssoHttpRoute.httpRoute.parentRefs | list | `[]` | Gateway API parentRefs for the HTTPRoute # Must reference an existing Gateway | | gatewayAPI.ssoHttpRoute.httpRoute.rules | list | `[{"backendRefs":[{"name":"users","port":8080}],"matches":[{"path":{"type":"RegularExpression","value":"^/api/users/v1/organizations/.+/scim/Groups(/.*)?$"}}]},{"backendRefs":[{"name":"users","port":8080}],"matches":[{"path":{"type":"RegularExpression","value":"^/api/users/v1/organizations/.+/scim/Users(/.*)?$"}}]}]` | HTTPRoute rules configuration | | gitProviders.azureDevOps.enabled | bool | `false` | Enable or disable the Azure DevOps integration (Services + Server 2020+) | | gitProviders.azureDevOps.webhookBasicAuthPass | string | `nil` | Basic auth password pipekit accepts on incoming ADO Service Hook deliveries | | gitProviders.azureDevOps.webhookBasicAuthUser | string | `nil` | Basic auth username pipekit accepts on incoming ADO Service Hook deliveries | | gitProviders.bitbucket.enabled | bool | `false` | Enable or disable the BitBucket Data Center integration | | gitProviders.bitbucket.webhookSecret | string | `"secret"` | bitbucket webhook secret | | gitProviders.github.appID | string | `nil` | Github application ID | | gitProviders.github.appName | string | `nil` | The name of your github app | | gitProviders.github.clientID | string | `nil` | Github OAuth client ID | | gitProviders.github.clientSecret | string | `nil` | Github OAuth client secret | | gitProviders.github.enabled | bool | `false` | Enable or disable the Github integration | | gitProviders.github.privateKey | string | `nil` | Github private key | | gitProviders.github.webhookSecret | string | `nil` | Github webhook secret (optional) | | gitProviders.gitlab.enabled | bool | `false` | Enable or disable the Gitlab integration | | gitProviders.gitlab.webhookSecret | string | `nil` | gitlab webhook secret | | global.adminPassword | string | A random password will be generated if not provided | Pipekit Admin password. This password is used internally by Pipekit services to authenticate with each other. | | global.breakGlassPassword | string | A random password will be generated if not provided | Pipekit Break Glass password. This password is used to access Pipekit in the event that SSO is unavailable. | | global.developmentMode | bool | `false` | Install non-production versions of postgres, redis and loki in-cluster. Useful for local development and evaluation Do not enable for production use | | global.developmentModeImages.lokiImage | string | `"grafana/loki:3.7.5"` | Image to use for the development mode Loki instance | | global.developmentModeImages.postgresImage | string | `"postgres:18.4"` | Image to use for the development mode Postgres instance | | global.developmentModeImages.redisImage | string | `"ghcr.io/valkey-io/valkey:9.1.1-alpine"` | Image to use for the development mode Redis instance | | global.imagePullPolicy | string | `Always` | Globally set an imagePullPolicy. | | global.imageRepo | string | `pipekitprivate` | Globally set the container image repository. You will need your docker hub pull secret to pull from there. Place it in `global.serviceAccount.imagePullSecrets` | | global.imageTag | string | The chart appVersion | Globally set the image tag. | | global.jwtSigningToken | string | A random token will be generated if not provided | Token used to create the JWT for users signing in to the Pipekit Services | | global.licenseKey | string | `nil` | License key for Pipekit. Either enter your license key here or create a kubernetes secret containing the key. Leave blank to use global.licenseKeySecretName | | global.licenseKeySecretName | string | `nil` | The name of the Kubernetes secret that contains the license key Leave blank to use global.licenseKey The named secret should be installed in the same namespace and should contain a key pair named `LICENSE_KEY` | | global.logLevel | string | `"INFO"` | Set the log level for all Pipekit services | | global.nodeSelector | object | `{}` | Set a nodeSelector to run Pipekit's services on specific nodes | | global.rotateAdminPassword | bool | `false` | Set to true to rotate the Pipekit Admin password | | global.rotateBreakGlassPassword | bool | `false` | Set to true to rotate the Pipekit Break Glass password | | global.rotateJwtSigningToken | bool | `false` | Set to true to rotate the JWT Signing Token. | | global.rotateSsoStoreSigningKey | bool | `false` | Set to true to rotate the SSO Store Signing Key | | global.serviceAccount.annotations | object | `{}` | Annotations applied to created service account | | global.serviceAccount.imagePullSecrets | list | `[]` | Secrets with credentials to pull images from a private registry | | global.serviceAccount.labels | object | `{}` | Labels applied to created service account | | global.serviceAccount.name | string | `"pipekit"` | Service account which is used to run the Pipekit services | | global.ssoStoreSigningKey | string | A random token will be generated if not provided | Token used to sign the SSO Sessions | | global.telemetryProtocols | string | `"prometheus"` | Which telemetry protocols to use: comma delimited selection of otel, prometheus. otel is controlled by the standardized opentelemetry environment variables prometheus enables metrics on :9090/metrics set to 'none' to disable all telemetry | | id.hpa.enabled | bool | `false` | Enable or disable the Horizontal Pod Autoscaler for this service | | id.hpa.maxReplicas | int | `10` | Set the maximum number of replicas for the Horizontal Pod Autoscaler | | id.hpa.minReplicas | int | `1` | Set the minimum number of replicas for the Horizontal Pod Autoscaler | | id.imageName | string | `"id"` | Optionally override the default image name for this service | | id.imageTag | string | `nil` | Optionally override the default image tag for this service | | id.livenessProbe | object | `{"failureThreshold":2,"httpGet":{"path":"/api/id/metrics/_health","port":8080},"initialDelaySeconds":70,"periodSeconds":5}` | Configure the liveness probe for this service | | id.pdb.enabled | bool | `true` | Enable or disable the Pod Disruption Budget for this service | | id.pdb.minAvailable | string | `"50%"` | Set the minimum number of pods available during a disruption | | id.pdb.unhealthyPodEvictionPolicy | string | `"AlwaysAllow"` | Set unhealthyPodEvictionPolicy on the PDB. Options: `IfHealthyBudget` or `AlwaysAllow` | | id.readinessProbe | object | `{"httpGet":{"path":"/api/id/metrics/_health","port":8080},"periodSeconds":5}` | Configure the readiness probe for this service | | id.resources.requests | object | `{"cpu":"20m","memory":"35Mi"}` | Set the resource requests for this service | | ingress.annotations | object | `{"nginx.ingress.kubernetes.io/client-body-buffer-size":"5m","nginx.ingress.kubernetes.io/from-to-www-redirect":"true","nginx.ingress.kubernetes.io/proxy-body-size":"5m","nginx.ingress.kubernetes.io/proxy-buffer-size":"5m","nginx.ingress.kubernetes.io/proxy-buffers-number":"32","nginx.ingress.kubernetes.io/proxy-busy-buffers-size":"5m"}` | Additional ingress annotations. Some optional nginx examples provided below | | ingress.enabled | bool | `true` | Enable or disable the main Pipekit Ingress | | ingress.host | string | `"pipekit.example.com"` | The host name to use for Pipekit | | ingress.ingressClassName | string | `"nginx"` | Defines which ingress controller will implement the resource | | ingress.labels | object | `{}` | Additional ingress labels | | ingress.ssoIngress.annotations | object | `{"nginx.ingress.kubernetes.io/client-body-buffer-size":"5m","nginx.ingress.kubernetes.io/from-to-www-redirect":"true","nginx.ingress.kubernetes.io/proxy-body-size":"5m","nginx.ingress.kubernetes.io/proxy-buffer-size":"5m","nginx.ingress.kubernetes.io/proxy-buffers-number":"32","nginx.ingress.kubernetes.io/use-regex":"true"}` | Additional ingress annotations. Some optional nginx examples provided below | | ingress.ssoIngress.enabled | bool | `false` | Enable or disable the SSO Ingress | | ingress.ssoIngress.host | string | `"pipekit.example.com"` | Must use the same host name as the main ingress at ingress.host | | ingress.ssoIngress.ingressClassName | string | `"nginx-public"` | Defines which ingress controller will implement the resource | | ingress.ssoIngress.labels | object | `{}` | Additional ingress labels | | ingress.ssoIngress.tls | list | `[]` | Ingress TLS configuration | | ingress.tls | list | `[]` | Ingress TLS configuration | | login.entraSSO.enabled | bool | `true` | Enable or disable the Entra SSO login and settings options | | login.githubSSO.clientID | string | `nil` | Client ID | | login.githubSSO.clientSecret | string | `nil` | Client secret | | login.githubSSO.enabled | bool | `false` | Enable or disable the Github SSO login option | | login.gitlabSSO.applicationID | string | `nil` | Application ID | | login.gitlabSSO.applicationSecret | string | `nil` | Application secret | | login.gitlabSSO.enabled | bool | `false` | Enable or disable the Gitlab SSO login option | | login.googleSSO.clientID | string | `nil` | Client ID | | login.googleSSO.clientSecret | string | `nil` | Client secret | | login.googleSSO.enabled | bool | `false` | Enable or disable the Google SSO login option | | login.microsoftSSO.clientID | string | `nil` | Client ID | | login.microsoftSSO.clientSecret | string | `nil` | Client secret | | login.microsoftSSO.enabled | bool | `false` | Enable or disable the Microsoft SSO login option | | login.oktaSSO.enabled | bool | `true` | Enable or disable the Okta SSO login and settings options | | login.userPass.enabled | bool | `true` | Enable or disable the username/password login option | | loki.gatewayAddress | string | `nil` | Optional. The address of a Loki gateway to use for both reading and writing logs. Valid prefixes are http\:// and https\:// | | loki.gatewayPort | integer | `3100` | The port of the loki gateway address | | loki.readAddress | string | `"http://loki-query-frontend.loki.svc.cluster.local"` | Used by the users service to read logs from Loki. If empty, loki.gatewayAddress is used. Valid prefixes are http\:// and https\:// | | loki.readPort | integer | `3100` | The port of the loki read address | | loki.writeAddress | string | `"http://loki-distributor.loki.svc.cluster.local"` | Used by the messenger service to send logs to Loki. If empty, loki.gatewayAddress is used. Valid prefixes are http\:// and https\:// | | loki.writePort | integer | `3100` | The port of the loki write address | | messenger.fluentbit.imageName | string | `"fluent-bit"` | Set the default image name for the fluentbit container | | messenger.fluentbit.imageRepo | string | `"fluent"` | Set the image repo for the fluentbit container | | messenger.fluentbit.imageTag | string | `"5.1.0"` | Set the default image tag for the fluentbit container | | messenger.fluentbit.resources | object | `{"requests":{"cpu":"100m","memory":"1.5Gi"}}` | Set the resource requests/limits for the fluentbit container | | messenger.fluentbit.resources.requests | object | `{"cpu":"100m","memory":"1.5Gi"}` | Set the resource requests for the fluentbit container | | messenger.hpa.enabled | bool | `false` | Enable or disable the Horizontal Pod Autoscaler for this service | | messenger.hpa.maxReplicas | int | `10` | Set the maximum number of replicas for the Horizontal Pod Autoscaler | | messenger.hpa.minReplicas | int | `1` | Set the minimum number of replicas for the Horizontal Pod Autoscaler | | messenger.imageName | string | `"messenger"` | Optionally override the default image name for this service | | messenger.imageTag | string | `nil` | Optionally override the default image tag for this service | | messenger.livenessProbe | object | `{"failureThreshold":2,"httpGet":{"path":"/api/messenger/metrics/_health","port":8080},"initialDelaySeconds":70,"periodSeconds":5}` | Configure the liveness probe for this service | | messenger.logRotate.resources.requests | object | `{"cpu":"50m","memory":"32Mi"}` | Set the resource requests for the logrotate container | | messenger.pdb.enabled | bool | `true` | Enable or disable the Pod Disruption Budget for this service | | messenger.pdb.minAvailable | string | `"50%"` | Set the minimum number of pods available during a disruption | | messenger.pdb.unhealthyPodEvictionPolicy | string | `"AlwaysAllow"` | Set unhealthyPodEvictionPolicy on the PDB. Options: `IfHealthyBudget` or `AlwaysAllow` | | messenger.readinessProbe | object | `{"httpGet":{"path":"/api/messenger/metrics/_health","port":8080},"periodSeconds":5}` | Configure the readiness probe for this service | | messenger.resources.requests | object | `{"cpu":"200m","memory":"64Mi"}` | Set the resource requests for the messenger service container | | openfga.apiToken | string | `nil` | API token for the OpenFGA server. Empty for an unauthenticated server. | | openfga.apiUrl | string | `nil` | URL of the OpenFGA API to connect to. Valid prefixes are http\:// and https\:// | | openfga.enabled | bool | `false` | Enable RBAC via OpenFGA | | openfga.storeName | string | `"pipekit"` | OpenFGA store display name; discovered or created by the users service on startup. | | pipekitInit.imageName | string | `"pipekit-init"` | Optionally override the default image name for this service | | pipekitInit.imageTag | string | `nil` | Optionally override the default image tag for this service | | postgresql.host | string | `"example.com"` | Database host URL | | postgresql.maxConnectionLifetime | int | `5` | Max connection lifetime in minutes | | postgresql.maxIdleConnections | int | `15` | Max idle connections | | postgresql.maxOpenConnections | int | `25` | Max open connections | | postgresql.maxRetries | int | `10` | Number of database connection retries | | postgresql.password | string | `"pipekit"` | Database password | | postgresql.port | int | `5432` | Database port | | postgresql.sslMode | string | `"disable"` | Enable or disable SSL mode | | postgresql.username | string | `"pipekit"` | Database username | | redis.connectionPoolSize | string | `nil` | connection pool size | | redis.host | string | `"redis.redis.svc.cluster.local"` | Redis host URL | | redis.masterName | string | `nil` | masterName of redis, only used when sentinelMode is true | | redis.password | string | `nil` | Optional Redis connection password | | redis.port | int | `6379` | Redis port | | redis.sentinelAddrs | string | `nil` | addresses of the form ":" separated by a ',' character of all the sentinel addresses | | redis.sentinelMode | bool | `false` | sentinelMode talks to redis-sentinel to get the master address, used for high availability. | | redis.tls.caCert | string | `nil` | CA certificate content for TLS connection to Redis. Only used if existingTLSSecret is not set. | | redis.tls.clientCert | string | `nil` | Optional client certificate content for TLS connection to Redis. Only used if existingTLSSecret is not set. | | redis.tls.clientKey | string | `nil` | Optional client key content for TLS connection to Redis. Only used if existingTLSSecret is not set. | | redis.tls.existingTLSSecret | string | `nil` | Name of existing secret containing Redis TLS certificates. The secret must contain the keys ca.crt, tls.crt, and tls.key. # Leave empty to use the certificate values provided below. | | redis.tls.serverName | string | `nil` | Optional Redis TLS server name. Used if redis.host is a CNAME to the redis endpoint defined in the CA Cert. | | redis.tls.tlsEnabled | bool | `false` | enable tls for redis connection | | redis.username | string | `nil` | Optional Redis connection username | | ui.hpa.enabled | bool | `false` | Enable or disable the Horizontal Pod Autoscaler for this service | | ui.hpa.maxReplicas | int | `10` | Set the maximum number of replicas for the Horizontal Pod Autoscaler | | ui.hpa.minReplicas | int | `1` | Set the minimum number of replicas for the Horizontal Pod Autoscaler | | ui.imageName | string | `"ui"` | Optionally override the default image name for this service | | ui.imageTag | string | `nil` | Optionally override the default image tag for this service | | ui.livenessProbe | object | `{"failureThreshold":2,"httpGet":{"path":"/metrics/_health","port":3000},"initialDelaySeconds":70,"periodSeconds":5}` | Configure the liveness probe for this service | | ui.pdb.enabled | bool | `true` | Enable or disable the Pod Disruption Budget for this service | | ui.pdb.minAvailable | string | `"50%"` | Set the minimum number of pods available during a disruption | | ui.pdb.unhealthyPodEvictionPolicy | string | `"AlwaysAllow"` | Set unhealthyPodEvictionPolicy on the PDB. Options: `IfHealthyBudget` or `AlwaysAllow` | | ui.readinessProbe | object | `{"httpGet":{"path":"/metrics/_health","port":3000},"periodSeconds":5}` | Configure the readiness probe for this service | | ui.resources.requests | object | `{"cpu":3,"memory":"250Mi"}` | Set the resource requests for this service | | users.hpa.enabled | bool | `false` | Enable or disable the Horizontal Pod Autoscaler for this service | | users.hpa.maxReplicas | int | `10` | Set the maximum number of replicas for the Horizontal Pod Autoscaler | | users.hpa.minReplicas | int | `1` | Set the minimum number of replicas for the Horizontal Pod Autoscaler | | users.imageName | string | `"users"` | Optionally override the default image name for this service | | users.imageTag | string | `nil` | Optionally override the default image tag for this service | | users.livenessProbe | object | `{"failureThreshold":2,"httpGet":{"path":"/api/users/metrics/_health","port":8080},"initialDelaySeconds":70,"periodSeconds":5}` | Configure the liveness probe for this service | | users.pdb.enabled | bool | `true` | Enable or disable the Pod Disruption Budget for this service | | users.pdb.minAvailable | string | `"50%"` | Set the minimum number of pods available during a disruption | | users.pdb.unhealthyPodEvictionPolicy | string | `"AlwaysAllow"` | Set unhealthyPodEvictionPolicy on the PDB. Options: `IfHealthyBudget` or `AlwaysAllow` | | users.readinessProbe | object | `{"httpGet":{"path":"/api/users/metrics/_health","port":8080},"periodSeconds":5}` | Configure the readiness probe for this service | | users.resources.requests | object | `{"cpu":"200m","memory":"64Mi"}` | Set the resource requests for this service | ## Redis TLS Configuration To enable TLS for Redis connections, set `redis.tls.tlsEnabled` to `true` and provide TLS certificates using one of the following methods: ### Option 1: Use an existing secret 1. Create a Kubernetes secret containing your Redis certificates: ```bash kubectl create secret generic redis-tls --from-file=ca.crt=/path/to/ca.crt --from-file=tls.crt=/path/to/tls.crt --from-file=tls.key=/path/to/tls.key ``` 2. Reference the secret in your values file: ```yaml redis: tls: tlsEnabled: true existingTLSSecret: redis-tls ``` ### Option 2: Provide certificate content directly You can provide the certificate content directly in your values file: ```yaml redis: tls: tlsEnabled: true caCert: | -----BEGIN CERTIFICATE----- MIIEBDCCAuygAwIBAgIDAjppMA0GCSqGSIb3DQEBCwUAMEIxCzAJBgNVBAYTAlVT ... -----END CERTIFICATE----- cert: | -----BEGIN CERTIFICATE----- MIIEBDCCAuygAwIBAgIDAjppMA0GCSqGSIb3DQEBCwUAMEIxCzAJBgNVBAYTAlVT ... -----END CERTIFICATE----- key: | -----BEGIN RSA PRIVATE KEY----- MIIEpAIBAAKCAQEA7EJtpBPcZP6kX/r+IkYWjJlmcXPme9oEBkXLhY1rSlwjEHQZ ... -----END RSA PRIVATE KEY----- ``` ## Upgrading Pipekit ### Checking the latest version Pipekit is automatically published to [Artifact Hub](https://artifacthub.io/packages/helm/pipekit-helm/pipekit). You can use this service to configure automatic notifications of new versions, either via an RSS feed or a webhook. Alternatively, you can search the Helm repo for the latest version of Pipekit using the following command: ```bash # Add the repo if you don't already have it. helm repo add pipekit https://helm.pipekit.io helm repo update helm search repo pipekit/pipekit --versions ``` For further information on the `helm search repo` command, please refer to the [official Helm documentation](https://helm.sh/docs/helm/helm_search_repo/). ### Changes to the default values.yaml Prior to upgrading, you should ensure that you understand any changes to the default values.yaml and the impact those changes may have on your installation. This page is always updated with the latest available Helm chart values for Pipekit. If you wish to upgrade to an older version of the Pipekit Helm chart, you can extract the default values for that version using the following command: ```bash helm show values pipekit/pipekit --version [version] ``` The Pipekit values file is commented so you can see what each value does. You can extract your existing values from your current installation using the following command: ```bash helm get values pipekit -n pipekit ``` For further information the helm commands used above, please refer to the [official Helm documentation](https://helm.sh/docs/helm/). ### Upgrading Pipekit To upgrade Pipekit, you can use the following command: ```bash helm upgrade -i -n pipekit \ -f myvalues.yaml \ pipekit pipekit/pipekit ``` For more information on using Helm to perform upgrades, please check [the official Helm documentation](https://helm.sh/docs/helm/helm_upgrade/). ### Automating the upgrades using Gitops If you use a Gitops tool such as Argo CD, you can commit your changes to your git repository and the tool will handle the Helm upgrade for you. If you wish to automate the upgrade process, we recommend a third party tool called [Renovate Bot](https://docs.renovatebot.com/) that can be configured to automatically raise pull requests for you when a new version of Pipekit is released. ### Upgrade Support If you have an issue upgrading Pipekit that isn't addressed here, please contact us over Slack, or by email at . # License Key Pipekit License Key Pipekit will not function without a valid license key. You can obtain a license key and the associated terms by contacting us at or through your Slack support channel. Without a valid key, users will be prevented from authenticating with Pipekit, and the Pipekit Agent will not be able to communicate with the Pipekit service. ## Applying the License Key To apply the license key, you will need to set the `global.licenseKey` value in your Helm Chart to the key provided by Pipekit. ## Monitoring for License Expiry The `users` service within the Pipekit deployment will output the number of seconds until the license expires, as a metric. You can monitor this metric to ensure that your license does not expire. Metrics for the users service are available at the `/metrics` endpoint of the users service on port 9090. ### Example Prometheus Rules The example below will issue a warning alert when your Pipekit license is due to expire in 30 days, and a critical alert if within 14 days. You can adjust the `expr` field to change the number of days before expiry that the alert is triggered. ```yaml apiVersion: monitoring.coreos.com/v1 kind: PrometheusRule metadata: name: pipekit-license-expiry spec: groups: - name: pipekit-license rules: - alert: expiresIn90Days annotations: description: "The license key for your Pipekit installation will expire in less than 30 days. Please renew the license key to avoid any disruptions. Email hello@pipekit.io for more information." summary: The Pipekit license key will expire in less than 30 days. expr: |- users_license_seconds_until_expiration / 86400 > 30 labels: severity: warning - alert: expiresIn14Days annotations: description: "The license key for your Pipekit installation will expire in less than 14 days. Please renew the license key to avoid any disruptions. Email hello@pipekit.io for more information." summary: The Pipekit license key will expire in less than 14 days. expr: |- users_license_seconds_until_expiration / 86400 > 14 labels: severity: critical ``` # Configure Initial login to Pipekit and how to use the Break Glass account After you first install Pipekit using the Helm Chart, you will need to log in to the application in order to set up the initial Organization. This guide will walk you through the steps to log in to Pipekit for the first time and how to use the Break Glass account in case you lose access to the application through SSO. We recommend that you use SSO wherever possible to log into Pipekit. However, the first user must be a non-sso account. When you install the Helm Chart, by default, a break glass account is created for you and the password is randomly generated and stored within your cluster. ## Retrieve the Break Glass credentials Assuming you installed the Pipekit Helm chart into the namespace `pipekit`, the username should be `pipekitbreakglass` but can be determined with this kubectl command: ```bash kubectl get secret pipekit-break-glass -n pipekit -o jsonpath="{.data.BREAK_GLASS_USERNAME}" | base64 --decode ``` The password is either the password you supplied in `global.breakGlassPassword` or, if you left that field blank you can obtain the randomly generated password using kubectl: ```bash kubectl get secret pipekit-break-glass -n pipekit -o jsonpath="{.data.BREAK_GLASS_PASSWORD}" | base64 --decode ``` When you log into the web interface for the first time, set up an Organization. ## Enabling SSO Modify your helm values file to enable SSO of your choice. e.g. setting `login.googleSSO.enabled` to `true` will enable Google SSO. Apply the update to your cluster. Where required, enter the secret key for your given SSO provider in the `values.yaml` file. Once the UI pod has restarted, log in with your SSO account. Your SSO user (and all subsequent SSO users) will be automatically added as a read-only user to the first Organization you created. Once logged in, log out. ### Okta and Entra SSO (SAML and SCIM) Okta and Entra SSO need to be set up via the Pipekit UI. For more information on setting up Okta and Entra SSO, refer to the [Okta SSO documentation](/organizations-and-access/sso/okta) and [Entra SSO documentation](/organizations-and-access/sso/entra). The org settings UI to do this is enabled by default. You can disable the org settings UI by setting `login.oktaSSO.enabled` and `login.entraSSO.enabled` to `false` in your `values.yaml` file and performing a helm upgrade. You must also expose some specific API endpoints to the internet for SCIM integration with Okta or Entra. This can be done by enabling and configuring the `ingress.ssoIngress` section in your [values.yaml](/self-hosting-pipekit/dependencies/helm-install) file. ## Changing the SSO user's role Log back into the application using your break glass username/password. Use this to elevate the permissions of your newly-added SSO user to an admin role. ## Disabling the username/password login boxes At this point, the username/password login box should not be required in day-to-day operations. You can disable it by setting `login.userpass.enabled` to `false` in your `values.yaml` file and then performing a helm upgrade. You can now use the SSO login to elevate access for other users, and to continue setting up a cluster. ## Using the Break Glass account If you encounter an emergency whereby you can't access Pipekit with SSO, you can use the Break Glass account to access the application for debugging or recovery purposes. Set `login.userpass.enabled` to `true`, perform a helm upgrade, and then log in with the Break Glass account. ## Rotating the Break Glass password This can be changed by setting a `global.rotateBreakGlassPassword` to true and running a helm upgrade. The password will be rotated and the new password will be stored in the secret `pipekit-break-glass` in the namespace you chose to install Pipekit. You can choose the password yourself by setting `global.breakGlassPassword` in your `values.yaml` file. # Configuring SSO Configuring SSO for self-hosted Pipekit installations These examples assume you are self-hosting Pipekit on the subdomain `pipekit.example.com`. Replace this with your actual domain. ## GitLab 1. Go to your GitLab group settings and click on "Applications" 2. Click on "New Application" 3. Fill in the details: * Name: \[Choose a unique App name] * Redirect URI: * Tick "Confidential" * Scopes: * read\_user * openid * profile * email 4. Click "Save application" 5. Note down the Application ID and Secret and pass them to the [Helm Chart Values](/self-hosting-pipekit/dependencies/helm-install) to configure Pipekit. ## Microsoft (Azure AD/Entra) Social Login 1. Create a new app registration in your Azure AD tenant. 2. Fill in the details: * Name: \[Choose a unique App name] * Supported account types: Choose the account types you want to support. * Redirect URI: * Platform: Web * 3. After creating the app, create a Client Secret and note it down. 4. Then add the following API permissions: * Microsoft Graph: * email * openid * profile * User.Read 5. Note the Application (client) ID and pass it along with the Client Secret to the [Helm Chart Values](/self-hosting-pipekit/dependencies/helm-install) to configure Pipekit. # Git Provider Integration Integrating with a Git provider such as GitHub, or GitLab Pipekit integrates with Git providers such as GitHub and GitLab so users can trigger Workflows from commits and pull requests. This guide will walk you through the steps to integrate them with Pipekit. These examples assume you are self-hosting Pipekit on the subdomain `pipekit.example.com`. Replace this with your actual domain. ## GitHub 1. Go to replacing `example` with your github organization. 2. Click on "New GitHub App" 3. Fill in the details: * GitHub App name: \[Choose a unique App name] * Homepage URL: * Callback URL: * Add a second Callback URL: * Tick "Request user authorization (OAuth) during installation" * Webhook URL: * Repository permissions: * Administration: Read & Write * Checks: Read & Write * Contents: Read & Write * Deployments: Read & Write * Pull requests: Read & Write * Webhooks: Read & Write * Subscribe to events: * Create * Pull request * Push * Repository 4. Click "Create GitHub App" 5. Generate a private key and download it as prompted. 6. Note down the App name, App ID, Client ID and generate a new Client Secret. 7. Populate the [Helm Chart Values](/self-hosting-pipekit/dependencies/helm-install) with the collected information and install Pipekit. 8. Install Pipekit and log in with [the Break Glass User account](/self-hosting-pipekit/initial-login). 9. Create an organization and cluster. Go back to the organization and click `settings` and then press the GitHub button to authenticate the Org with GitHub. 10. Install the Github App into the repo(s) you wish Pipekit to interact with. ## GitLab 1. Enable `gitProviders.gitlab.enabled` in the [Helm Chart Values](/self-hosting-pipekit/dependencies/helm-install) to configure Pipekit to use GitLab. 2. Go to your Organization settings in Pipekit and click on "GitLab" to authenticate your Organization with GitLab. 3. Enter a PAT that has the following scopes: * api * read\_user * read\_repository 4. Choose a random string for the `gitProviders.gitlab.webhookSecret` and apply it to the Helm chart values. This will be used to automatically create a webhook in GitLab to post events to Pipekit. ## BitBucket Data Center 1. Enable `gitProviders.bitbucket.enabled` in the [Helm Chart Values](/self-hosting-pipekit/dependencies/helm-install) to configure Pipekit to use BitBucket. 2. Ensure a secure `gitProviders.bitbucket.webhookSecret` is set. This is used to automatically create webhooks in BitBucket to notify Pipekit. 3. Go to your Organization settings in Pipekit and click on "BitBucket Data Center" to authenticate your Organization with GitLab. 4. Enter your HTTP access token that has the following rights: * PROJECT\_READ * REPO\_ADMIN ## Azure DevOps Pipekit supports both Azure DevOps Services (cloud, `dev.azure.com/{org}`). One Pipekit account corresponds to one Azure DevOps organization; projects within that organization are surfaced in Pipekit's repo picker grouped under their project name. ### Helm chart configuration 1. Enable `gitProviders.azureDevOps.enabled` in the [Helm Chart Values](/self-hosting-pipekit/dependencies/helm-install). 2. Set `gitProviders.azureDevOps.webhookBasicAuthUser` and `gitProviders.azureDevOps.webhookBasicAuthPass` to a username/password pair of your choice. Pipekit configures every Service Hook subscription it creates to deliver with these Basic auth credentials and verifies them on each incoming delivery. ### Authentication: Personal Access Token (PAT) Create a PAT with the permissions in the table below, then connect the account in Pipekit by submitting the organization URL (`https://dev.azure.com/{org}` for Services, your server URL for Server) and the PAT. | Permission | Why Pipekit needs it | Required or optional | | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------ | | **Code** (Read) | Clone the repo and read files, refs, tags, and the default branch, and list repositories in the picker | Required | | **Code** (Status) | Post pipe run status back to commits and pull requests | Optional (only when commit statuses are enabled) | | **Project & Team** (Read) | Resolve a project name to its GUID when registering Service Hook subscriptions | Optional (only when Pipekit creates the hooks) | | [**Edit subscriptions**](https://learn.microsoft.com/en-us/azure/devops/service-hooks/view-permission?view=azure-devops) (project permission, not a PAT scope) | Create and delete [Service Hook](https://learn.microsoft.com/en-us/azure/devops/service-hooks/overview?view=azure-devops) subscriptions on the repo | Optional (only when Pipekit creates the hooks) | The last three rows are gated by the two write toggles described in [Limiting Pipekit's writes](#limiting-pipekits-writes-to-azure-devops). With manual service hooks, both **Project & Team (Read)** and **Edit subscriptions** become unnecessary; drop **Code (Status)** too if you disable commit statuses. A fully read-only setup (manual hooks and no commit statuses) needs only **Code (Read)**. {% hint style="info" %} **Edit subscriptions** is a project-level permission, not a PAT scope. It is held by a **Project Administrator** or granted directly to the identity. Microsoft made the old `vso.hooks*` PAT scope [private](https://learn.microsoft.com/en-us/azure/devops/integrate/get-started/authentication/oauth?view=azure-devops), so this permission is the only way to authorize hook creation. {% endhint %} Pipekit never writes to your repository contents. Its only writes to Azure DevOps are Service Hook subscriptions and commit statuses, and both can be turned off per account. ### Service Hooks Pipekit creates three Service Hook subscriptions per repo on first attach: `git.push`, `git.pullrequest.created`, and `git.pullrequest.updated`. Pull request updates are filtered to source-branch push notifications. Branch creation, tag creation, and tag updates are all carried by `git.push`. Cleanup on detach removes all three. There is no global Service Hook subscription — every repo manages its own. ### Webhook delivery URL `https:///api/events-handler/v1/events/azure-devops` ### Limiting Pipekit's writes to Azure DevOps Pipekit never writes to your repository contents. Its only writes are Service Hook subscriptions and commit statuses, and each can be disabled per account from the **Connect Azure DevOps** dialog: * **I'll create the service hooks manually** stops Pipekit from creating or deleting Service Hook subscriptions. Enable this if you cannot grant the Edit subscriptions permission. You must then create the subscriptions yourself (see below), otherwise commits and pull requests will not trigger pipes. * **Don't post commit statuses to Azure DevOps** stops Pipekit from posting run status back to commits and pull requests. Enable this if you do not want to grant the **Code (Status)** scope. #### Creating service hooks manually {% hint style="warning" %} Azure DevOps service hooks are created per repository, per event. Every repository you use in a pipe needs **all three** of these subscriptions: `git.push`, `git.pullrequest.created`, and `git.pullrequest.updated`. There is no project-wide or account-wide hook, so for *N* repositories you create *3 × N* subscriptions in total. {% endhint %} For each repository, create all three of these subscriptions: * **Code pushed** (`git.push`) — also carries branch and tag creation, so no separate hook is needed for those. * **Pull request created** (`git.pullrequest.created`). * **Pull request updated** (`git.pullrequest.updated`) — also set the change filter to the source-branch push option (`PushNotification`) so that only new commits trigger a run, not reviewer or vote changes. All three share the same URL and Basic auth; only the trigger differs. Create each one as follows: 1. In Azure DevOps, open **Project settings** (the gear icon at the bottom of the left sidebar). 2. Under **General**, select **Service hooks**, then click the **+** (plus) icon. 3. For the service, select **Web Hooks**, then click **Next**. 4. Select the trigger and set its **Repository** filter to the target repository, then click **Next**. You must set the **Repository** filter; leaving it unset delivers events for every repository in the project, and Azure DevOps bills per delivery. 5. In **URL**, enter the [webhook delivery URL](#webhook-delivery-url). 6. In **Basic authentication username** and **Basic authentication password**, enter the pair you configured for Pipekit (see the note below). Optionally click **Test** to confirm Pipekit returns `200`, then click **Finish**. Repeat these steps for all three triggers, then for every other repository you attach to a pipe. {% hint style="info" %} The Basic authentication username and password are **not** an Azure DevOps user. They are an arbitrary pair you invent purely to secure the webhook payloads. Pipekit's events handler holds the same pair, set through the `gitProviders.azureDevOps.webhookBasicAuthUser` and `gitProviders.azureDevOps.webhookBasicAuthPass` Helm values (exposed to the service as the `AZURE_DEVOPS_WEBHOOK_BASIC_AUTH_USER` and `AZURE_DEVOPS_WEBHOOK_BASIC_AUTH_PASS` environment variables), and uses it to verify that each incoming delivery is authentic. The pair must be identical in every subscription and in your Helm values, and neither value may be empty, or Pipekit rejects the delivery with `401 Unauthorized`. {% endhint %} {% hint style="info" %} Config-as-code and namespace-permission triggers use their own hooks. If you use config-as-code, create all three subscriptions again with the `?type=config-as-code` variant of the delivery URL. If you use namespace permissions, create only a **Code pushed** (`git.push`) subscription with the `?type=permission` variant. Do not create pull request subscriptions for the `?type=permission` variant. Pipekit handles pull request events the same way regardless of the `type` parameter, so the extra hooks would trigger duplicate runs. {% endhint %} ## Limiting Pipekit's requests to your git provider You can cap how many API requests per minute Pipekit sends to your git provider. Set the limit in `Settings` > `Accounts` using the `API rate limit (requests/min)` field. Leave the field empty for no limit. The limit applies to the connected account as a whole: every Pipekit component that talks to your git provider shares the same budget, no matter how many replicas are running. Requests beyond the budget wait for the next available slot instead of failing, so short bursts are smoothed out rather than rejected. Waiting is capped at 2 minutes: a request that cannot get a slot within that time (or before its own timeout) fails with a timeout error rather than queueing indefinitely. {% hint style="info" %} Setting a limit adds a Redis check to every git provider request. If Redis is unavailable, requests for rate-limited accounts fail rather than exceed the configured cap. {% endhint %} ## Next Steps If you haven't done so, continue to [create a cluster](/using-pipekit/clusters) and then [create a pipe](/using-pipekit/pipes) to start using Pipekit. You have now successfully integrated your git provider with your Organization. This will allow you to use a number of Pipekit's features: * [Create Pipes](/using-pipekit/pipes) that run Workflows stored in your Git repositories. * Create and manage Pipes that use [Run Conditions](/using-pipekit/pipes/edit/run-sync-conditions) to trigger Workflows on GitHub events. * The [WorkflowTemplates](/using-pipekit/templates) features of Pipekit. * Manage [Workflow Priorities](/using-pipekit/clusters#queuing) * Manage [Namespace Permissions](/organizations-and-access/permissions) through GitOps. ## Populating the repository cache in Pipekit If you enable a Git Provider, a Kubernetes cron job will be installed into the cluster that will run every night to query your git provider for an updated list of Pipekit-accessible repositories and store them in the Pipekit database. This is done to ensure that Pipekit has the most up-to-date list of repositories to work with and prevents excessive API calls to your git provider. # Pipekit Agent Configuration Configuring the Pipekit Agent for self-hosted Pipekit installations When using a self-hosted Pipekit installation, the Pipekit Agent requires additional configuration to communicate with your Pipekit services instead of the SaaS cloud service. The Pipekit Agent connects clusters running Argo Workflows to your Pipekit installation. For detailed installation instructions, refer to the [main Pipekit Agent documentation](/reference/helm-values/agent). ## Required Configuration for Self-Hosted Pipekit When installing the Pipekit Agent, you **must** configure two additional parameters to point to your self-hosted Pipekit installation: * `configMap.messengerBaseUri`: Points to the Pipekit Messenger service * `configMap.usersBaseUri`: Points to the Pipekit Users service ## Deployment Scenarios ### Remote Cluster (Recommended) In large-scale installations, it is recommended to run the Pipekit Agent on a different cluster from your Pipekit installation to isolate the effects of your workflows from the Pipekit installation. When the Pipekit Agent runs on a different cluster from your Pipekit installation, use your external ingress URLs: ```yaml configMap: messengerBaseUri: "https://pipekit.example.com" usersBaseUri: "https://pipekit.example.com" ``` This configuration uses your external Pipekit domain and routes through your ingress controller using HTTPS for secure external communication. ### Same Cluster as Pipekit Control Plane Some load balancers may not support hair-pinning, so it is recommended to use internal cluster DNS to avoid this. To use internal cluster DNS, use something like the following configuration: ```yaml configMap: messengerBaseUri: "http://messenger.pipekit.svc.cluster.local:8080" usersBaseUri: "http://users.pipekit.svc.cluster.local:8080" ``` This configuration uses internal Kubernetes service DNS (`svc.cluster.local`) to avoid network hair-pinning issues and provides the most reliable connectivity. This uses HTTP, but the traffic is lower-risk as it remains within your cluster network # AI Use AI agents with Pipekit through the Model Context Protocol (MCP) server. Pipekit ships an MCP (Model Context Protocol) server inside its CLI. When you run `pipekit mcp`, the CLI exposes Pipekit's capabilities as MCP tools and resources that any compatible LLM client (Claude Desktop, Cursor, Claude Code, Goose) can call on your behalf. That means you can use an AI agent to do the work you'd otherwise do through the UI, CLI, or Python SDK: * **Debug a failed Run**: the agent fetches the Run, pulls the workflow node graph, reads the pod logs, and tells you what broke. See [Patterns > Debug a Failed Run](/ai/debug-failed-run). * **Author a Workflow**: the agent reads the workflow-authoring guides shipped with the MCP server, drafts a Workflow YAML, validates it offline, and submits it. See [Patterns > Author a Workflow](/ai/debug-failed-run/author-workflow). * **Automate operations**: schedule recurring work, suspend a cron, update a cluster, import an Argo Workflow Archive. See [Patterns > Automate Operations](/ai/debug-failed-run/automate-ops). ## What the MCP server exposes The server registers **19 tools** covering Pipekit's read and write surface: list and inspect clusters/pipes/runs, fetch run logs, submit/stop/terminate/restart workflows, manage cron schedules, import from an Argo workflow archive. Each tool is annotated with the standard MCP `readOnlyHint` and `destructiveHint` so compatible clients can render warnings or apply approval policies. For the full inventory and per-tool hints, see [Tool Inventory](/ai/tool-inventory). The server also publishes reference resources (Argo workflow schemas, examples, and Pipekit how-to guides) that the LLM can list and read on demand. This lets an agent learn how Pipekit and Argo work without you pasting docs into the chat. ## Get started 1. [Set up the MCP server](/ai/setup): install Pipekit's CLI, log in once, then add the MCP server to your LLM client. 2. Try a pattern: [Debug a Failed Run](/ai/debug-failed-run), [Author a Workflow](/ai/debug-failed-run/author-workflow), or [Automate Operations](/ai/debug-failed-run/automate-ops). 3. If something doesn't work, see [Troubleshooting](/ai/troubleshooting). ## Security model The MCP server inherits your CLI's identity (the token at `~/.pipekit/token`). The agent can do exactly what you can do, no more. For the auth model, transports (stdio and HTTP), and the rules around binding to non-loopback addresses, see [Security & Transports](/ai/security-and-transports). # Setup Install and configure the Pipekit MCP server for Claude Desktop, Cursor, Claude Code, and other MCP clients. Run the Pipekit CLI as a Model Context Protocol ([MCP](https://modelcontextprotocol.io/)) server so LLM clients can read and modify Pipekit resources on your behalf. ## Prerequisites * The Pipekit CLI installed (see [Reference > CLI > Install](/reference/cli#installation)). * You have run `pipekit login` at least once, so that a token is on disk at `~/.pipekit/token` (or `$PIPEKIT_CONFIG_DIR/token` if that env var is set). * An MCP-capable LLM client (Claude Desktop, Cursor, Claude Code, Goose, etc.). The MCP server reads your token fresh on every authenticated tool call. If your token expires, run `pipekit login` again. The next tool call picks up the new token without restarting the server. ## Configuration recipes The snippets below all assume the `pipekit` binary is on your `PATH`. If it isn't, replace `pipekit` with the absolute path (e.g. `/usr/local/bin/pipekit`). ### Claude Desktop Edit `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows): ```json { "mcpServers": { "pipekit": { "command": "pipekit", "args": ["mcp"] } } } ``` Restart Claude Desktop. The Pipekit tools appear under the tool/plug icon in the prompt area. ### Cursor Edit `~/.cursor/mcp.json` (or the project-scoped `.cursor/mcp.json`): ```json { "mcpServers": { "pipekit": { "command": "pipekit", "args": ["mcp"] } } } ``` Reload the Cursor window. Pipekit tools become available to the agent. ### Claude Code The recommended path is the CLI command, which writes the configuration to `~/.claude.json` (user scope) for you: ```bash claude mcp add pipekit pipekit mcp ``` For project-scoped configuration, create or edit `.mcp.json` in the project root with the same `mcpServers` block shown above for Claude Desktop and Cursor. ### Generic MCP-compatible client Any client that supports the stdio transport can run the server directly. The minimum command is: ```bash pipekit mcp ``` The server speaks newline-delimited JSON-RPC over stdio per the MCP specification. ## Verifying the install Once your client is connected, ask the agent to call `pipekit_version`. If you get back a Pipekit version string, the server is running and the agent has access. If `pipekit_version` returns but other tools fail with `401 unauthorized`, your local CLI token isn't on disk. Run `pipekit login`. ## Logging `pipekit mcp` honors the same `--log-level` and `--log-format` flags as the rest of the CLI: ```bash pipekit mcp --log-level=debug --log-format=json ``` Logs go to stderr so they don't interfere with the MCP protocol stream on stdout. ## What's next * [Tool Inventory](/ai/tool-inventory): every tool the server exposes and which are destructive. * [Security & Transports](/ai/security-and-transports): stdio vs HTTP, auth, identity. * [Troubleshooting](/ai/troubleshooting): common failure modes. * [Patterns](/ai/debug-failed-run): worked examples of using AI with Pipekit. # Tool Inventory The 19 MCP tools the Pipekit server exposes, with their destructive-hint annotations. The Pipekit MCP server registers 19 tools. Each tool is annotated with the standard MCP `readOnlyHint` and `destructiveHint` so compatible LLM clients (Claude Desktop, Cursor, Claude Code) can render appropriate warnings or apply approval policies. The annotation rules are: * **Read-only tools** (`list_*`, `get_*`, `version`) carry `readOnlyHint: true`. Safe by definition. * **Additive tools** that only create new resources (`submit_workflow`, `restart_run`, `create_cron`, `trigger_cron`, `import_workflows`) carry `destructiveHint: false`. They do change state, but they don't overwrite or delete existing resources. * **Mutating or deleting tools** carry `destructiveHint: true`. Clients that honor MCP annotations prompt before calling these. ## MCP tools | Tool | Hints | Purpose | | ------------------- | --------------------------------- | --------------------------------------------------------------------- | | `version` | readOnly | Return the CLI / server version. | | `list_clusters` | readOnly | List Clusters in the current Organization. | | `list_pipes` | readOnly | List Pipes on a Cluster (paginated, filterable). | | `list_runs` | readOnly | List Runs (paginated, filter by Pipe / status / cluster / namespace). | | `get_run` | readOnly | Fetch one Run by UUID or by `(cluster, namespace, workflow name)`. | | `get_workflow_node` | readOnly | Fetch one node inside a Run's workflow graph. | | `get_run_logs` | readOnly | Fetch a snapshot of container logs for a Run, with grep/head/tail. | | `submit_workflow` | destructiveHint: false (additive) | Submit a Workflow YAML to a Cluster. | | `restart_run` | destructiveHint: false (additive) | Resubmit a Run with the same parameters. | | `stop_run` | destructiveHint: true | Gracefully stop a Run (exit handlers complete). | | `terminate_run` | destructiveHint: true | Terminate a Run immediately (no exit handlers). | | `update_cluster` | destructiveHint: true | Update a Cluster's name, description, or status. | | `create_cron` | destructiveHint: false (additive) | Create a CronWorkflow on a Cluster. | | `update_cron` | destructiveHint: true | Update an existing CronWorkflow. | | `delete_cron` | destructiveHint: true | Delete a CronWorkflow. | | `suspend_cron` | destructiveHint: true | Suspend a CronWorkflow (stops scheduling new Runs). | | `resume_cron` | destructiveHint: true | Resume a suspended CronWorkflow. | | `trigger_cron` | destructiveHint: false (additive) | Run a CronWorkflow immediately, regardless of schedule. | | `import_workflows` | destructiveHint: false (additive) | Import workflows from an Argo Workflow Archive into Pipekit. | The live source of truth is the registry at [`tools/cli/cmd/mcp/tools/registry.go`](https://github.com/pipekit/pipeline-mono/blob/master/tools/cli/cmd/mcp/tools/registry.go). For the parameter schema of each tool, ask your MCP client to introspect the server (every MCP client has a way to list tools and their input schemas). ## MCP resources In addition to tools, the server publishes a library of read-only resources the agent can list and fetch on demand: * **Argo workflow schemas**: the `Workflow` and `CronWorkflow` JSON schemas. * **Workflow examples**: small reference workflows the agent can crib from. * **Pipekit how-to guides**: `pipekit://guides/{debugging-a-failed-run,workflow-authoring,parameters-and-artifacts,template-types,submitting-workflows,importing-workflows,cron-workflows,identifiers,offline-lint-templateref-footgun}`. The guides are shipped with the CLI binary, not fetched from the network, so they're available even when the agent is offline relative to . # Patterns Use an AI agent to investigate a failed Pipekit Run. A common path: a Run failed, the failure is somewhere in the workflow graph, and you want the agent to triage it before you look at it yourself. ## How the agent diagnoses a failed Run Given a Run UUID (or a Pipe name and cluster), the agent: 1. Calls `get_run` to fetch the Run's status, parameters, and overall metadata. 2. Calls `get_workflow_node` to walk the workflow node graph and identify the failed node(s). 3. Calls `get_run_logs` with a `nodeId` filter (and optional `grep` / `tail`) to pull the relevant log lines. 4. Reads the `pipekit://guides/debugging-a-failed-run` MCP resource if it needs to know more about how to interpret Argo node statuses. 5. Summarizes the root cause and suggests a remediation (re-submit with different params, fix YAML, escalate). The agent never has to learn this flow from your chat. The MCP server ships with the guide as a resource, so the agent can fetch it on demand. ## Example: debug a Run by UUID ``` Run 266dfb27-0690-4ed3-bf53-26e9a96c6a87 just failed. Look at it, find which node failed, pull the logs, and tell me what broke. ``` The agent will iterate through tool calls, possibly fetching the debugging guide too, and respond with a diagnosis. ## What the agent can't do (yet) * Stream logs as a Run progresses. `get_run_logs` returns a snapshot. For live following, use the CLI's `pipekit logs -f` directly. * Modify or re-author the failing workflow's YAML automatically. The agent can suggest changes, but you (or another tool call) need to re-submit. ## Permission notes This pattern uses only read-only tools (`get_run`, `get_workflow_node`, `get_run_logs`). No approval prompt should fire in MCP-annotation-aware clients. For the full list of read-only tools, see [Tool Inventory](/ai/tool-inventory). # Author a Workflow Use an AI agent to author and submit a new Argo Workflow. Drafting a new Argo `Workflow` from scratch is one of the higher-friction tasks in Argo. The YAML is verbose, template references are easy to mis-type, and parameter/artifact passing has its own conventions. An AI agent connected to the Pipekit MCP server can short-circuit a lot of that because the server ships authoring guidance as resources. ## How the agent authors and submits a Workflow Given a goal (e.g. "build a DAG that fans out over a list and aggregates"), the agent: 1. Reads `pipekit://guides/workflow-authoring` for Pipekit-specific submission rules and limits. 2. Reads `pipekit://guides/parameters-and-artifacts` and `pipekit://guides/template-types` to pick the right template type and parameter passing strategy. 3. Reads `pipekit://guides/offline-lint-templateref-footgun` if the workflow references shared `WorkflowTemplates` (this guide covers the most common authoring mistake: referencing a Template that won't resolve when the workflow runs). 4. Drafts the workflow YAML. 5. Optionally calls `list_clusters` to confirm the target cluster name. 6. Calls `submit_workflow` to submit. ## Example: S3 fanout DAG to Slack ``` I want a Workflow that: - Pulls a list of files from S3 - Fans out, one task per file - Aggregates the per-file outputs into a single summary - Posts the summary to Slack Submit it to cluster `data-dev`, namespace `argo`, service account `argo-workflow`. ``` The agent drafts a `Workflow` with a DAG template, an artifact-based fanout, and a final aggregation step. It calls `submit_workflow` once it has a complete spec. You'll be prompted to confirm `submit_workflow` if your client honors MCP annotations (it's additive, not destructive, but most clients still prompt on any state change). ## Argo Workflow authoring best practices * **Always set `namespace` and `serviceAccountName`.** The agent will ask if you don't specify them. If you can't be bothered, paste your team's defaults into the prompt. The agent will reuse them. * **Specify `generateName`, not `name`.** This is the convention that lets [Pipe](/concepts/pipe) group Runs together. The authoring guide makes the same point. * **Validate locally if you can.** Argo's `argo lint` will catch most YAML problems before submission. If your team has a local validation step, mention it in the prompt and the agent will run it before calling `submit_workflow`. ## Permission notes `submit_workflow` is annotated `destructiveHint: false` (additive: creates a new Run, never overwrites). MCP-annotation-aware clients may still prompt before any tool that changes state. For the full list, see [Tool Inventory](/ai/tool-inventory). # Automate Operations Use an AI agent for operational tasks: managing cron schedules, updating clusters, importing workflows. Operational work on Pipekit doesn't always need a human reading dashboards. The MCP server exposes enough write-side tools to let an agent run routine ops. This is the most powerful (and the most destructive) pattern. Read [Security & Transports](/ai/security-and-transports) before granting an agent these tools, and lean on the `destructiveHint: true` annotation to require approval prompts. ## Operations the agent can run The exact flow depends on the task. A few common shapes: ### Manage CronWorkflows The agent uses `create_cron`, `update_cron`, `suspend_cron`, `resume_cron`, `delete_cron`, and `trigger_cron` to manage scheduled workflows. Typical prompt: > Pause the `nightly-export` cron on all clusters until I tell you to resume it. The agent calls `list_runs` or queries Pipes to find the cron, then `suspend_cron` per cluster. For the underlying model, the MCP server ships `pipekit://guides/cron-workflows` as a resource. The agent reads it as needed. ### Update Cluster metadata `update_cluster` changes a Cluster's name, description, or active status. Typical prompt: > Mark cluster `eu-west-2` as inactive. We're decommissioning it next week. The agent calls `list_clusters` to confirm the name, then `update_cluster` with `--status=inactive`. ### Import from an Argo Workflow Archive `import_workflows` walks an Argo Workflow Archive and surfaces the archived workflows as Pipes in Pipekit. Typical prompt: > Import the last 30 days of workflows from the archive at `argo-server:2746` into cluster `data-prod`. The agent calls `import_workflows` with the appropriate `--argoServerURI` and `--cluster-name` parameters. For the underlying mechanics, the agent can fetch `pipekit://guides/importing-workflows`. ## Safe use of destructive MCP tools * **Use the HTTP transport with a dedicated token** if you want fine-grained control over what the agent can reach. See [Security & Transports](/ai/security-and-transports). * **Run a dedicated agent against a non-prod Organization first.** Operational tools change real state. Practice in dev before pointing the agent at production. * **Honor MCP annotations.** `destructiveHint: true` exists because clients can prompt before destructive calls. Make sure your client surfaces those prompts. ## Permission notes This pattern uses several `destructiveHint: true` tools. In MCP-annotation-aware clients, the agent has to ask for approval before calling them. For the full list of which tools are destructive, see [Tool Inventory](/ai/tool-inventory). # Security & Transports MCP transports, authentication model, and the security boundaries around \`pipekit mcp\`. ## Transports The CLI supports two transports: * **stdio** *(default)*: the LLM client launches `pipekit mcp` as a subprocess and talks to it over stdin/stdout. This is the recommended path for local LLM-client integrations. * **HTTP** *(opt-in)*: `pipekit mcp --transport=http` runs an HTTP server speaking [Streamable HTTP](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http) for clients that don't fork subprocesses. ### stdio transport When a client launches `pipekit mcp` as a subprocess, there's no network surface to defend. All authentication flows through the local CLI token on disk. ### HTTP transport The HTTP transport defaults to binding `127.0.0.1:8080` and **refuses to bind a non-loopback address unless you also pass `--allow-remote`**. This is a defense against accidentally exposing the MCP server to the LAN. Every HTTP request must carry an `Authorization: Bearer ` header. The token is taken from `--token`, then from `$PIPEKIT_MCP_TOKEN`, otherwise the server generates a fresh 32-byte hex token at startup and prints it to stderr. Loopback binds additionally apply a Host-header allowlist (matching the bind-side loopback rule) to defend against [DNS rebinding](https://en.wikipedia.org/wiki/DNS_rebinding_attack). ```bash # loopback HTTP (default address; token is generated and printed) pipekit mcp --transport=http # explicit loopback IP and operator-supplied token PIPEKIT_MCP_TOKEN=$(openssl rand -hex 32) pipekit mcp --transport=http --addr=127.0.0.1:9000 # bind a non-loopback interface (LAN/container); requires opt-in pipekit mcp --transport=http --addr=0.0.0.0:8080 --allow-remote ``` ## Authentication and identity Tools call into the same Pipekit APIs the CLI itself uses. Each call runs with the identity of the user whose token is at `~/.pipekit/token` (or `$PIPEKIT_CONFIG_DIR/token` if that env var is set). If you switch organizations with `pipekit login`, subsequent tool calls reflect the new context. Practical implications: * The agent can do exactly what you can do, no more and no less. * [Access Control](/concepts/access-control) bindings apply to MCP tool calls the same way they apply to CLI commands. * If your token expires, MCP tool calls return `401 unauthorized` until you run `pipekit login` again. No server restart needed. ## Per-tool approval There is no per-tool approval gate built into the stdio server itself. That policy lives in the LLM client. Clients that honor MCP tool annotations prompt before calling tools annotated with `destructiveHint: true`. For the per-tool annotations and which tools are destructive, see [Tool Inventory](/ai/tool-inventory). If your client doesn't surface MCP annotations, assume **every** tool the agent has access to is callable without prompting. Use HTTP transport with an explicit token (or a dedicated CLI token via `$PIPEKIT_CONFIG_DIR`) to bound what the agent can reach. # Troubleshooting Common failure modes for the Pipekit MCP server and how to resolve them. ## No tools appear in the client Confirm the binary path is correct and that the client started the subprocess. Most MCP clients log the subprocess's stderr. Check there for an authentication or startup error. If the subprocess isn't launching: * Make sure `pipekit` is on the client process's `PATH`, not just your shell's. GUI clients (Claude Desktop, Cursor) often don't inherit your shell's `PATH`. Either install Pipekit to `/usr/local/bin` or use the absolute path in your client config. * Check the config file syntax. JSON has no trailing commas; a missing closing brace silently disables the server in most clients. ## `401 unauthorized` errors For HTTP transport, first verify the request includes the correct `Authorization: Bearer ` header (`--token` / `$PIPEKIT_MCP_TOKEN` / the auto-generated value printed at startup). If the bearer token is correct (or you are on the stdio transport), your Pipekit token has expired. Run `pipekit login` and try again. The next tool call picks up the new token without restarting the server. ## Tools list but return errors when called Run `pipekit list clusters` from the same shell. If that fails, the CLI itself is misconfigured (network, login, permissions) and the MCP server will fail in the same way. Fix the CLI first; the MCP server will start working automatically. ## Agent has access to wrong Organization The MCP server uses the CLI token on disk. Running `pipekit login` against a different Organization switches the token; subsequent tool calls reflect the new context. If you want one agent connected to Org A and another to Org B simultaneously, point each at a separate token store via `$PIPEKIT_CONFIG_DIR`: ```bash # Org A agent PIPEKIT_CONFIG_DIR=~/.pipekit-org-a pipekit mcp # Org B agent PIPEKIT_CONFIG_DIR=~/.pipekit-org-b pipekit mcp ``` Run `pipekit login` once against each `PIPEKIT_CONFIG_DIR` to populate the corresponding token. ## Tools the agent calls don't return the latest data Pipekit doesn't cache between tool calls. Every call hits the live API. If the agent shows stale data, it's caching the result in its own conversation context. Ask the agent to re-fetch (call `list_runs` or `get_run` again). # Concepts Definitions of Pipekit's core terms. Pipekit introduces a handful of terms on top of Argo Workflows. This section defines each one and points into the task-oriented documentation under [Using Pipekit](/using-pipekit) for the day-to-day surface. If you're new to Pipekit, start with [Workflow vs Pipe vs Run](/concepts/workflow-vs-pipe-vs-run). It disambiguates the three terms readers most often confuse. ## Core terms * [Pipe](/concepts/pipe): A logical container for one Argo `Workflow` definition and the history of every run of it. * [Run](/concepts/run): A single execution of a Pipe. * [Workflow vs Pipe vs Run](/concepts/workflow-vs-pipe-vs-run): Disambiguating Argo's `Workflow`, Pipekit's `Pipe`, and Pipekit's `Run`. * [Cluster](/concepts/cluster): A Kubernetes cluster registered with Pipekit. * [Organization](/concepts/organization): Pipekit's top-level tenant. * [Pipekit Agent](/concepts/pipekit-agent): The in-cluster component that brokers commands and status between Pipekit and Argo. * [Templates](/concepts/templates): Reusable `WorkflowTemplate` and `ClusterWorkflowTemplate` definitions Pipekit manages across clusters. * [Cron & Externally Triggered](/concepts/cron-and-externally-triggered): Execution models that bypass direct submission. * [Access Control](/concepts/access-control): Workspaces, roles, and IdP group bindings. * [Pipekit Cloud vs Self-Hosted](/concepts/cloud-vs-self-hosted): Deployment models, side by side. # Pipe An Argo Workflow definition and all of its runs in Pipekit. A Pipe is Pipekit's container for one Argo `Workflow` definition and every run of that workflow. Each Pipe groups runs by the workflow's `generateName` (or `name`) so you can see history, logs, and metrics for the same logical workflow across submissions. A Pipe belongs to one [Organization](/concepts/organization) and runs on one or more [Clusters](/concepts/cluster) you have registered with Pipekit. You'll encounter Pipes whenever you submit a workflow. Pipekit creates a Pipe the first time it sees a workflow with a given name; later submissions of the same name produce new [Runs](/concepts/run) inside that Pipe. For the terminology fork between Argo's `Workflow`, Pipekit's `Pipe`, and Pipekit's `Run`, see [Workflow vs Pipe vs Run](/concepts/workflow-vs-pipe-vs-run). For task-oriented documentation, see [Using Pipekit > Pipes](/using-pipekit/pipes). # Run A single execution of a Pipe. A Run is one execution of the workflow associated with a [Pipe](/concepts/pipe). Every time Pipekit submits the Pipe's workflow to a [Cluster](/concepts/cluster), it creates a Run. Submissions can come from the CLI, the UI, a Git event, a cron schedule, or an external trigger. The Run captures status, start and end times, parameters, pod logs, and the workflow node graph. Pipekit retains Runs indefinitely; old Runs are never garbage-collected. You can stop, terminate, retry, or resubmit any Run from the Pipekit UI or CLI. Workflow lifecycle commands map directly to Argo Workflows operations on the underlying `Workflow` resource. Pipekit is a thin layer over Argo's existing semantics. For task-oriented documentation, see [Using Pipekit > Runs](/using-pipekit/runs). # Workflow vs Pipe vs Run Disambiguating Argo's \`Workflow\`, Pipekit's \`Pipe\`, and Pipekit's \`Run\`. These three terms are easy to confuse because they overlap. | Term | Owner | What it is | | ---------- | ------- | --------------------------------------------------------------------------------------------------- | | `Workflow` | Argo | The Kubernetes custom resource. The YAML you write; the spec Argo executes. | | `Pipe` | Pipekit | A logical container for one `Workflow` definition and the history of every run of it. | | `Run` | Pipekit | A single execution of the `Workflow` inside a Pipe. Each submission produces a new Run in the Pipe. | The hierarchy is one-to-many in one direction. One `Workflow` definition → one Pipe → many Runs. A Pipe is created the first time Pipekit sees a `Workflow` with a given `generateName` (or `name`); subsequent submissions of the same workflow create new Runs inside the same Pipe rather than new Pipes. Pipekit does not replace or hide Argo's `Workflow`. The Pipe and Run are Pipekit-side metadata; the underlying Kubernetes object running in your cluster is still an Argo `Workflow`, managed by the Argo Workflow Controller. For the day-to-day surfaces, see [Pipes](/using-pipekit/pipes) and [Runs](/using-pipekit/runs). # Cluster A Kubernetes cluster registered with Pipekit. A Cluster in Pipekit is a Kubernetes cluster that runs Argo Workflows and has the [Pipekit Agent](/concepts/pipekit-agent) installed. Each Cluster you register belongs to one [Organization](/concepts/organization) and is the execution target for [Runs](/concepts/run) of the Pipes scoped to it. Pipekit communicates with the Cluster through the Pipekit Agent, which runs in-cluster alongside Argo and brokers commands and status between Pipekit's control plane and your workflow engine. You'll encounter Clusters during initial setup (connect one before you can submit any workflows) and during day-to-day operations: a Pipe Run targets a specific Cluster, and disaster recovery flows let you fail Pipes over from one Cluster to another. For task-oriented documentation, see [Using Pipekit > Clusters](/using-pipekit/clusters) and the [disaster recovery runbook](/using-pipekit/clusters/disaster-recovery). # Organization The top-level tenant in Pipekit. Your team's workspace. An Organization is Pipekit's top-level tenant. It owns your [Clusters](/concepts/cluster), [Pipes](/concepts/pipe), members, alert providers, secrets environments, and identity provider integration. Organizations are isolated from each other. Members of one Organization cannot see another Organization's Pipes or Runs; access control, SSO mappings, and audit boundaries all stop at the Organization boundary. When you first sign up to Pipekit Cloud, you'll be prompted to create an Organization. Self-hosted deployments start with a single Organization that you bootstrap as part of the install. Within an Organization, [Access Control](/concepts/access-control) further scopes who can see and act on Pipes, Runs, and Clusters via workspaces, roles, and IdP group bindings. For task-oriented documentation, see [Organizations & Access](/organizations-and-access). # Pipekit Agent About the Pipekit Agent The Pipekit Agent is a small application that runs within your Kubernetes cluster. It acts as the conduit to Pipekit's API, allowing you to run Argo Workflows from your local machine or through a Git repository. The Pipekit Agent triggers Argo Workflows based on the configuration you set in Pipekit. It also sends the status of the Argo Workflow back to Pipekit, allowing you to see the status of your workflows in the Pipekit UI. Optionally, the Pipekit Agent can also send the logs of your Argo Workflows to Pipekit. ## Pipekit Agent Software Bill of Materials (SBOM) An SBOM for the Pipekit Agent is embedded within the container image in SPDX format. Further information is available on the [SBOM](/why-pipekit/security#pipekit-software-bill-of-materials-sbom) page. # Pipekit Cloud vs Self-Hosted Pipekit Cloud and Self-Hosted Pipekit deployment models, side by side. Pipekit ships in two deployment shapes. Both run the [Pipekit Agent](/concepts/pipekit-agent) inside your Kubernetes [Cluster](/concepts/cluster); they differ in where the control plane (UI, API, database) lives. | Component | Pipekit Cloud | Self-Hosted | | ------------------ | ------------------------------------------------- | ----------------------------------------------- | | Control plane | Hosted by Pipekit | Hosted by you (Kubernetes via Helm) | | Pipekit Agent | Runs in your cluster | Runs in your cluster | | Argo Workflows | Runs in your cluster | Runs in your cluster | | Workflow data | Stored in your cluster; metadata in Pipekit Cloud | Stored entirely in your infrastructure | | Logs | Optional: Pipekit Cloud or your own backend | Your own backend (optional Pipekit log storage) | | Identity provider | Configured per Organization | Configured per Organization | | Network connection | Outbound only (agent → Pipekit Cloud via Redis) | All in-cluster; can run fully air-gapped | Choose Pipekit Cloud for the fastest evaluation path and lowest operational overhead. Choose Self-Hosted when your security, compliance, or air-gapping requirements rule out a hosted control plane. To evaluate Pipekit Cloud, see [Get Started > Evaluate Pipekit Cloud](/get-started/evaluate-cloud). To deploy Self-Hosted, see [Self-Hosting Pipekit](/self-hosting-pipekit). # Cron & Externally Triggered How Cron and Externally Triggered Workflows differ from regular Pipe submissions. Most [Runs](/concepts/run) are created when you (or a teammate, or a Git event) submit a `Workflow` to Pipekit. Two other execution models bypass that path. ## CronWorkflows A `CronWorkflow` is an Argo construct that schedules a `Workflow` to run on a recurring cron expression. In Pipekit, a Pipe whose underlying YAML is a `CronWorkflow` behaves the same as any other Pipe, except submissions update the existing schedule on the cluster instead of creating a new Run. The Runs you see in the Pipe are produced by the Argo scheduler when the cron expression fires. You can suspend, resume, trigger immediately, or delete `CronWorkflows` from the Pipekit UI, the Pipekit CLI, or by editing the YAML in Git. For task-oriented documentation, see [Using Pipekit > Pipes > Cron](/using-pipekit/pipes/cron). ## Externally Triggered Workflows An externally triggered Workflow is a `Workflow` that started outside of Pipekit. It is submitted directly to your cluster via `kubectl`, Argo CLI, Argo Events, Argo API, or any other path that bypasses Pipekit. Pipekit can be configured to discover these Workflows via the in-cluster informer and surface them in the same Pipes and Runs UI as Pipekit-submitted Workflows. This is useful during migration to Pipekit, or for teams who want to keep an existing submission method but still get Pipekit's observability surface. The feature is opt-in and is enabled in the Pipekit Agent's Helm values. For task-oriented documentation, see [Using Pipekit > Pipes > Externally Triggered](/using-pipekit/pipes/externally-triggered). # Templates Reusable Argo Workflow definitions, managed by Pipekit across clusters. A Template in Pipekit is an Argo `WorkflowTemplate` or `ClusterWorkflowTemplate` that Pipekit manages on your behalf. Templates let you define a workflow once and reference it from many Pipes. Pipekit version-controls Templates against your Git repository and propagates updates to every cluster a Template is registered on. A Template lives in one place but executes anywhere you've connected to Pipekit. A Pipe can reference a Template via `templateRef` in its workflow spec. Pipekit will pin the version of the Template that the Pipe uses, or follow `latest` to track the default branch of the Template's Git repository. You'll encounter Templates when you want to: * Share a reusable workflow component (a build step, a data ingestion task, a release procedure) across teams or environments. * Pin production Pipes to a specific Template version while letting development Pipes follow `latest`. * Manage `ClusterWorkflowTemplate` resources across more than one cluster without applying YAML to each cluster by hand. For task-oriented documentation, see [Using Pipekit > Templates](/using-pipekit/templates). # Access Control Role-based access control (RBAC) lets your organization define who can see, run, and manage workflows — scoped to the teams and environments you define. {% hint style="warning" %} This feature is in alpha. Behavior may change before general availability. {% endhint %} Access is enforced at the Pipekit API level and tied to your existing identity provider. ## Core concepts ### Workspaces A workspace is a named scope that binds **one or more** `{cluster, namespace}` pairs and serves as the unit of access control. Every pipe, run, and template in Pipekit belongs to exactly one workspace. **Each `{cluster, namespace}` pair can only belong to one workspace.** Users and groups are granted access at the workspace level. A user with access to `team-data` has no visibility into `team-ml`. Workspaces are fully isolated in both the UI and API. | Workspace | Cluster | Namespace | | -------------- | ------------ | --------- | | `team-data` | cluster-dev | data-dev | | | cluster-prod | data-prod | | `team-ml` | cluster-dev | ml-dev | | `team-ml-prod` | cluster-prod | ml-prod | ### Roles Each user or group is assigned one role per workspace. Bindings are additive — when a user holds access at both org scope and workspace scope, the higher-privilege role applies. An org-scoped Admin is always an Admin in every workspace; a workspace-scoped Viewer binding cannot reduce that. | Role | Binding scope | What they can do | | ------------------- | ---------------- | -------------------------------------------------------------------------------------------------- | | **Org Admin** | Org only | Manage users, clusters, workspaces, SSO mappings, and role bindings across the entire organization | | **Workspace Admin** | Org or Workspace | Manage workspace settings, users, secrets, and alerts | | **Editor** | Org or Workspace | Create, edit, and delete WorkflowTemplates and CronWorkflows; submit and manage workflow runs | | **Runner** | Org or Workspace | Submit workflows; stop, terminate, retry, and restart runs; view logs | | **Viewer** | Org or Workspace | Read-only access to pipes, runs, logs, and templates (no secrets visibility) | Org Admin is the only role restricted to *org scope* — it manages org-level entities that don't exist at workspace level. ### Groups and binding scopes {% hint style="info" %} Roles are assigned to IdP groups rather than individual users. {% endhint %} When a user's group membership changes in your identity provider, their Pipekit access updates automatically — no manual intervention required. Bindings operate at two scopes: * **Org scope** — applies to all workspaces automatically. Use this for platform, ops, or admin groups that need cross-workspace access. Binding at org scope is a scale convenience — one binding instead of one per workspace. * **Workspace scope** — applies to a single named workspace. Use this for team-level access where different groups need different roles in different environments. ``` # Org-scoped — applies to all workspaces idp:team:platform → Org Admin → all workspaces idp:team:ops → Viewer → all workspaces idp:team:shared-tools → Editor → all workspaces # Workspace-scoped — applies to one workspace only idp:team:data-engineers → Runner → team-data-dev idp:team:data-engineers → Viewer → team-data-prod ``` The role's action set is unchanged regardless of scope. For cross-workspace read-only access — for example a platform ops team that monitors all teams — bind Viewer at *org scope*. When a user belongs to both an org-scoped group and a workspace-scoped group, the higher-privilege role applies: ``` idp:team:platform → Org Admin → all workspaces idp:team:foo → Viewer → team-foo-dev # A platform engineer in both groups gets Admin in team-foo-dev, not Viewer ``` Org-level access is never silently reduced by a workspace binding. If a group should not have elevated access in a specific workspace, do not give them an org-scoped role — use explicit workspace bindings instead. {% hint style="info" %} Individual user overrides are not supported in the current release. Access is managed at the group level. {% endhint %} ## SSO and identity provider integration Pipekit integrates with Okta and Microsoft Entra. Once SSO is configured for your organization: * Users authenticate exclusively via your identity provider; password login is disabled for your organization's email domains * Users must be invited to Pipekit by an Org Admin before their first login; once accepted, their access is determined by their IdP group membership * Removing a user from your IdP revokes their ability to authenticate with Pipekit * Users who are not members of any mapped group can log in but will have no access — they will see an empty Pipekit with a prompt to contact their Org Admin SSO is configured once by an Org Admin. Setup instructions are available for [Okta](/organizations-and-access/sso/okta) and [Microsoft Entra](/organizations-and-access/sso/entra). ## Permission reference | Action | Org Admin | WS Admin | Editor | Runner | Viewer | | -------------------------------------------------- | :-------: | :------: | :----: | :----: | :----: | | **Org management** | | | | | | | Invite & remove users | ✓ | | | | | | Manage clusters | ✓ | | | | | | Manage RBAC (workspaces, bindings, SSO mappings) | ✓ | | | | | | **Workspace settings** | | | | | | | Manage workspace settings & alerts | | ✓ | | | | | **Pipes** | | | | | | | View pipes & cron schedules | | ✓ | ✓ | ✓ | ✓ | | Create / edit pipes | | ✓ | ✓ | | | | Delete pipes | | ✓ | | | | | Rotate pipe deploy key | | ✓ | | | | | **Secrets** | | | | | | | View secret environments | | ✓ | ✓ | ✓ | | | Create / edit secrets | | ✓ | ✓ | | | | Delete secret environments | | ✓ | | | | | **Runs** | | | | | | | View runs & logs | | ✓ | ✓ | ✓ | ✓ | | Submit workflows | | ✓ | ✓ | ✓ | | | Cancel / retry / stop workflows | | ✓ | ✓ | ✓ | | | **Templates & config** | | | | | | | View templates | | ✓ | ✓ | ✓ | ✓ | | Manage workflow templates (create / edit / delete) | | ✓ | ✓ | | | | Manage cron schedules (suspend / resume) | | ✓ | ✓ | | | | Config as code | | ✓ | | | | ## How access is enforced ### Default-deny No access is granted implicitly. A user must have an explicit workspace binding to interact with any pipe, run, or cluster in Pipekit. Namespaces added to a cluster are inaccessible to all users until an Org Admin explicitly binds them to a workspace. ### Workspace isolation in the UI Users see only the workspaces they have access to. Clusters, pipes, runs, and templates from other workspaces are not visible — they are absent from all views, not hidden behind a permission error. ### Submission enforcement When a workflow is submitted — via the UI, CLI, or Python SDK — Pipekit checks that the authenticated user has a binding in a workspace that covers the target cluster and namespace. If not, the submission is rejected before it reaches the workflow engine. Pipekit does not modify the workflow spec; it validates access and either allows or rejects. ### Scope of enforcement Pipekit enforces access at the Pipekit API and UI layer. {% hint style="warning" %} Users who have direct `kubectl` or Argo UI access to a cluster are not constrained by Pipekit RBAC — enforcement at that layer is handled by Kubernetes RBAC, which remains under your platform team's control. {% endhint %} ## Bootstrapping your organization When you first set up Pipekit, the user who creates the organization is automatically assigned Org Admin. From there: 1. **Configure SSO** — connect your identity provider and enforce domain-locked authentication 2. **Connect clusters** — register the Kubernetes clusters Pipekit will submit workflows to 3. **Create workspaces** — define your initial workspaces and bind the relevant `{cluster, namespace}` pairs 4. **Map IdP groups to roles** — assign roles to your IdP groups at org or workspace scope 5. **Invite your first users** — invite Org Admins and Workspace Admins by email; once they accept they can begin onboarding their teams Until SSO is configured, users authenticate with email and password. Once SSO is enforced, password login is disabled for your organization's email domains and all new users must go through your identity provider. {% hint style="info" %} Configure SSO and map at least one IdP group to Org Admin before inviting other users. This ensures access management is owned by your identity provider from the start. {% endhint %} ## Setting up a team The typical flow for onboarding a new team: 1. **Create a workspace** — give it a name and bind the relevant `{cluster, namespace}` pairs 2. **Map IdP groups to roles** — e.g. `team-data-engineers` → Runner in dev, Viewer in prod; `team-data-leads` → Editor in both 3. **Invite users** — an Org Admin invites users by email; once they accept and log in via SSO, their access is determined by their IdP group membership ```bash # As Org Admin: see who can submit in a given workspace pipekit rbac who-can submit --workspace=team-data-dev ``` # Reference Reference material for Pipekit's interfaces. This section documents Pipekit's interfaces: * [CLI](/reference/cli): the `pipekit` command line. * [REST API](/reference/rest-api): the HTTP API. * [Python SDK](/reference/python-sdk): `pipekit-sdk` on PyPI. * [Helm Chart Values](/reference/helm-values): chart configuration reference. # CLI The Pipekit CLI lets you interact with Pipekit services without leaving your terminal. The `pipekit` CLI is the command-line surface for Pipekit. Everything the UI does is also doable from the CLI: submit Workflows, list Runs, stop or restart a Run, manage [CronWorkflows](/reference/cli/cron-workflows), import from an Argo Workflow Archive. The CLI also hosts the [MCP Server](/reference/cli/mcp) that lets LLM clients (Claude Desktop, Cursor, Claude Code, Goose) call Pipekit on your behalf. ## On this page * [Install](/reference/cli/install): how to install the CLI on macOS, Linux, Windows, and NixOS. * [Commands](/reference/cli/commands): the core command surface (`login`, `submit`, `get run`, `list`, `stop` / `terminate` / `restart`, `logs`, `update cluster`, `import workflows`). * [Using with Hera](/reference/cli/using-with-hera): generate tokens for Hera workflows and pair the CLI with the [Pipekit Python SDK](/reference/python-sdk). * [Advanced](/reference/cli/advanced): Docker container usage, non-interactive login, token storage, log-level flags, SBOM extraction. * [Cron Workflows](/reference/cli/cron-workflows): CronWorkflow lifecycle commands. * [MCP Server](/reference/cli/mcp): pointer to the [AI section](/ai/setup). ## Release notes Release notes are published on the [Pipekit Releases site](https://releases.pipekit.io). ## Quick reference ```bash # Install (macOS / Linux) brew install pipekit/tap/cli # Log in pipekit login # List clusters you have access to pipekit list clusters # Submit a workflow pipekit submit --cluster-name= path/to/workflow.yaml # View logs for a Run pipekit logs --run-uuid= --follow ``` # Install Install the Pipekit CLI on macOS, Linux, Windows, and NixOS. Install via your platform's package manager, or grab a precompiled binary from the [Pipekit CLI releases page](https://github.com/pipekit/cli/releases). ## macOS & Linux (Homebrew) ```bash brew install pipekit/tap/cli ``` * [Homebrew homepage](https://brew.sh/) ## Windows (Scoop) ```bash scoop bucket add pipekit https://github.com/pipekit/scoop.git scoop install pipekit/cli ``` * [Scoop homepage](https://scoop.sh/) ## NixOS & Nix Install from nixpkgs: ```bash nix profile install nixpkgs#pipekit ``` In a NixOS or home-manager configuration: ```nix environment.systemPackages = [ pkgs.pipekit ]; ``` {% hint style="info" %} The Pipekit CLI is proprietary, so the Nix derivation is marked `unfree`. Set `NIXPKGS_ALLOW_UNFREE=1` before installing, or allow the package in your NixOS or home-manager configuration via `nixpkgs.config.allowUnfreePredicate`. {% endhint %} ### Bleeding-edge channel The nixpkgs entry updates after each CLI release lands a maintainer-reviewed bump PR, so it lags the GitHub release by a few days. To install the newest CLI release immediately, use the interim flake: ```bash nix profile install github:pipekit/pipekit-nix ``` * [Nix homepage](https://nixos.org/) * [`pipekit/pipekit-nix` source](https://github.com/pipekit/pipekit-nix) ## Docker container A Wolfi-based Docker image ships with each CLI release. Pull `pipekit13/cli:` and run it: ```bash docker run \ -e PIPEKIT_USERNAME=myusername \ -e PIPEKIT_PASSWORD=mypassword \ pipekit13/cli \ pipekit login && \ pipekit list clusters ``` The `latest` tag is pinned to the latest released version of the Pipekit CLI. (To find a specific version, [check the tags on Docker Hub](https://hub.docker.com/r/pipekit13/cli/tags).) Containers are available in `linux/amd64` and `linux/arm64` variants. Both use [Wolfi](https://github.com/wolfi-dev) Linux as the base image. For more involved container patterns (copying the CLI into your own image, embedding it in a Workflow), see [Advanced > Docker container](/reference/cli/advanced#docker-container). ## Software Bill of Materials (SBOM) An SBOM for the CLI container is embedded within the container image in SPDX format. For extraction commands and signing verification, see [Why Pipekit > Security > Software Bill of Materials](/why-pipekit/security#software-bill-of-materials-sbom). ## Verify the install ```bash pipekit --version ``` If you don't see a version string, check that the install directory is on your `PATH`. ## What's next * [Log in](/reference/cli/commands#log-in) and start submitting Workflows. * For Hera workflows, see [Using with Hera](/reference/cli/using-with-hera). # Commands The Pipekit CLI's core commands: login, submit, get run, list, stop/terminate/restart, logs, update cluster, import workflows. Every command listed here is also doable via the [REST API](/reference/rest-api), the [Python SDK](/reference/python-sdk), and the UI. For the MCP Server (LLM client integration), see [AI > Setup](/ai/setup). ## Log in ```bash pipekit login ``` You'll be prompted to pick either username/password or SSO, depending on how your account was created. After login, the CLI stores your access token at `~/.pipekit/token` (override via `PIPEKIT_CONFIG_DIR`). For non-interactive login (CI, containers), see [Advanced > Non-interactive login](/reference/cli/advanced#non-interactive-login). ## Submit a workflow ```bash pipekit submit --cluster-name= --namespace= path/to/workflow.yaml ``` If no Pipe with the workflow's `generateName` exists on the cluster, Pipekit creates one. Subsequent submissions of the same workflow add new Runs to the existing Pipe. For the Pipe / Run model, see [Concepts > Workflow vs Pipe vs Run](/concepts/workflow-vs-pipe-vs-run). | Flag | Shorthand | Type | Description | | ---------------- | --------- | ----------------------- | ------------------------------------------------------------ | | `--namespace` | `-n` | string | Name of the namespace to submit the workflow to. | | `--cluster-name` | `-c` | string | Name of the cluster to submit the workflow to. **Required.** | | `--open-ui` | | bool | Open the UI for the submitted workflow. | | `--parameter` | `-p` | stringArray (key=value) | Pass input parameter(s). | | `--wait` | `-w` | bool | Wait for the submitted workflow to complete. | | `--pipe-name` | `-d` | string | Name of the Pipe to submit the workflow to. | | `--json` | | bool | Output the run details in JSON format. | ## Get information about a Run ```bash pipekit get run --run-uuid= ``` You can also look up a Run by `(cluster, namespace, workflow-name)`: ```bash pipekit get run --cluster-name=clusterA --namespace=default --workflow-name=workflowA ``` If multiple Runs match, the latest one is returned. | Flag | Shorthand | Type | Description | | ----------------- | --------- | ------ | ------------------------------------------------------- | | `--run-uuid` | `-r` | string | Run UUID of the workflow you want to get. | | `--cluster-name` | `-c` | string | Name of the cluster where the workflow is located. | | `--namespace` | `-n` | string | Kubernetes namespace where the workflow is/was running. | | `--workflow-name` | `-w` | string | Name of the workflow. | ## List clusters, Pipes, and Runs ### List clusters ```bash pipekit list clusters ``` ### List Pipes ```bash pipekit list pipes --cluster-name= ``` | Flag | Shorthand | Type | Description | | ---------------- | --------- | ------ | ----------------------------------------------- | | `--all` | `-A` | bool | Get all Pipes, both enabled and disabled. | | `--cluster-name` | `-c` | string | Name of the cluster to list from. **Required.** | | `--enabled` | | bool | Enabled/disabled switch (default true). | ### List Runs ```bash pipekit list runs --cluster-name= ``` | Flag | Shorthand | Type | Description | | ---------------- | --------- | ----------- | --------------------------------------------------- | | `--cluster-name` | `-c` | string | Name of the cluster to list from. | | `--all` | `-A` | bool | Get all Runs, regardless of status. | | `--statuses` | `-s` | stringArray | Get Runs with a given status (defaults to running). | ## Run actions: stop, terminate, restart ```bash # Stop a running workflow (exit handlers complete) pipekit stop --run-uuid= # Terminate a running workflow immediately (no exit handlers) pipekit terminate --run-uuid= # Resubmit a workflow with the same parameters pipekit restart --run-uuid= ``` `stop` and `terminate` take the same flag: | Flag | Shorthand | Type | Description | | ------------ | --------- | ------ | -------------------------------------------------------------------------- | | `--run-uuid` | `-r` | string | Run UUID of the running workflow you want to stop/terminate. **Required.** | `restart` takes: | Flag | Shorthand | Type | Description | | ------------ | --------- | ------ | ------------------------------------------------------ | | `--run-uuid` | `-r` | string | Run UUID of the run you want to restart. **Required.** | | `--open-ui` | | bool | Open the UI of the resubmitted workflow. | | `--wait` | `-w` | bool | Wait for the workflow to complete. | ## View pod logs ```bash pipekit logs --run-uuid= --follow ``` Filter by pod and container name; follow the stream to tail logs as they're produced. | Flag | Shorthand | Type | Description | | ------------- | --------- | ------ | ------------------------------------------ | | `--run-uuid` | `-r` | string | UUID of the Run. **Required.** | | `--container` | `-c` | string | Name of the container to filter logs by. | | `--pod` | `-p` | string | Name of the pod to filter logs by. | | `--node-id` | `-n` | string | ID of the workflow node to filter logs by. | | `--follow` | `-f` | bool | Follow log stream until the Run finishes. | ## Update a cluster ```bash pipekit update cluster --status=active pipekit update cluster --name=production --description="Production cluster" ``` Requires admin permissions. | Argument/Flag | Type | Description | | --------------- | ------ | --------------------------------------------------------- | | `cluster-name` | string | Name of the cluster to update. **Required (positional).** | | `--name` | string | New name for the cluster. | | `--description` | string | New description for the cluster. | | `--status` | string | New status for the cluster (`active` or `inactive`). | ## Import from Workflow Archive Admins can import archived workflows from an [Argo Workflow Archive](https://argo-workflows.readthedocs.io/en/stable/workflow-archive/) into Pipekit: ```bash pipekit import workflows --cluster-name= ``` {% hint style="warning" %} The import of [Workflow Archive Logs](https://argo-workflows.readthedocs.io/en/stable/configure-archive-logs/) is not supported. {% endhint %} | Flag | Shorthand | Type | Description | | --------------------- | --------- | ------- | ------------------------------------------------------------------------------------- | | `--cluster-name` | `-c` | string | Name of the cluster to assign workflows to. **Required.** | | `--argoServerURI` | | string | Argo Server URI (defaults to `localhost:2746`). | | `--argoAuthToken` | | string | Argo Server authentication token. | | `--batchSize` | | integer | Number of workflows to fetch from the Workflow Archive per API call (defaults to 10). | | `--argoServerSubPath` | | string | Sub-path used when connecting to Argo Server. | | `--insecure` | `-k` | bool | Skip TLS verification (defaults to false). | | `--useSSL` | | bool | Use SSL when connecting to Argo Server (defaults to true). | ## What's next * [Cron Workflows](/reference/cli/cron-workflows): CronWorkflow lifecycle commands. * [Using with Hera](/reference/cli/using-with-hera): token generation for Hera-authored workflows. * [Advanced](/reference/cli/advanced): Docker container usage, non-interactive login, token storage, log-level flags. # Using with Hera Pair the Pipekit CLI with Hera workflows and the Pipekit Python SDK. [Hera](https://github.com/argoproj-labs/hera) is a Python framework for authoring Argo `Workflows`. The Pipekit CLI integrates with Hera by issuing tokens you pass into the [Pipekit Python SDK](/reference/python-sdk), which submits your Hera-authored workflows to Pipekit. ## Generate a token ```bash pipekit login # one-time pipekit hera # prints a token to stdout ``` If you want only the token value (no banner), use `-r` for raw output: ```bash pipekit hera -r ``` The token is a bearer token, the same format the [REST API](/reference/rest-api) and the [MCP Server](/ai/setup) use. ## Use the token in Python ```python from pipekit_sdk.service import PipekitService import os pipekit = PipekitService(token=os.environ["PIPEKIT_TOKEN"]) ``` Then author your workflow with Hera and submit it via the SDK: ```python from hera.workflows import DAG, Workflow, script @script(image="python:3.12") def echo(message): print(message) with Workflow( generate_name="dag-diamond-", entrypoint="diamond", namespace="argo", service_account_name="argo-workflow", ) as w: with DAG(name="diamond"): A = echo(name="A", arguments={"message": "A"}) B = echo(name="B", arguments={"message": "B"}) C = echo(name="C", arguments={"message": "C"}) D = echo(name="D", arguments={"message": "D"}) A >> [B, C] >> D pipe_run = pipekit.submit(w, "") print(pipe_run["uuid"]) ``` For worked examples, see: * [Python SDK > Jupyter Notebooks](/reference/python-sdk/examples-jupyter) * [Python SDK > Python Scripts](/reference/python-sdk/examples-scripts) ## CronWorkflows with Hera Hera and the SDK also support the full CronWorkflow lifecycle. See [Python SDK > CronWorkflows](/reference/python-sdk#cronworkflows). ## Token lifetime The token Pipekit issues for Hera carries the same TTL as your CLI session. For long-running Python scripts that exceed the session length, refresh the token by running `pipekit login` and re-issuing `pipekit hera`. # Advanced Advanced Pipekit CLI usage. Docker container patterns, non-interactive login, token storage, log-level flags. For the standard install and command flow, see [Install](/reference/cli/install) and [Commands](/reference/cli/commands). This page covers patterns you'll reach for in CI, containers, or multi-account setups. ## Non-interactive login Log in by passing credentials as arguments: ```bash pipekit login -u username -p password # or pipekit login --user username --password password ``` Or via environment variables: ```bash export PIPEKIT_USERNAME=username export PIPEKIT_PASSWORD=password pipekit login ``` This is the path the [Docker container](#docker-container) section and CI runners take. ## Token storage location By default, the CLI writes the access token to `~/.pipekit/token`. Set `PIPEKIT_CONFIG_DIR` to point at a different directory; the CLI then reads and writes `$PIPEKIT_CONFIG_DIR/token`: ```bash export PIPEKIT_CONFIG_DIR=/tmp/pipekit-ci pipekit login -u username -p password ``` Use this when: * Running the CLI in CI, containers, or integration tests where each invocation needs an isolated token store. * Running multiple agents (e.g. [MCP servers](/ai/setup)) against different Organizations from the same host. ## Logging flags The CLI accepts `--log-level` and `--log-format` on every command: ```bash pipekit login --log-level=debug --log-format=json ``` | Flag | Values | Default | | -------------- | ----------------------------------------- | ------- | | `--log-level` | `debug`, `info`, `warn`, `error`, `fatal` | `info` | | `--log-format` | `text`, `json` | `text` | JSON logging is the right choice when feeding CLI output into a log aggregator. ## Docker container The basics of running `pipekit13/cli` are in [Install > Docker container](/reference/cli/install#docker-container). This section covers more involved patterns. ### Used within a workflow Embed the CLI inside an Argo Workflow step: ```yaml apiVersion: argoproj.io/v1alpha1 kind: Workflow metadata: name: pipekit-cli spec: entrypoint: main templates: - name: main dag: tasks: - name: pipekit-cli template: pipekit-cli - name: pipekit-cli env: - name: PIPEKIT_USERNAME valueFrom: secretKeyRef: name: pipekit-credentials key: username - name: PIPEKIT_PASSWORD valueFrom: secretKeyRef: name: pipekit-credentials key: password container: image: pipekit13/cli command: - sh - -c - | pipekit login pipekit list clusters resources: requests: memory: 10Mi cpu: 10m ``` ### Used within another container Copy the CLI binary into a container you control. This example adds it to a Jupyter notebook image: ```dockerfile FROM jupyter/scipy-notebook COPY --from=pipekit13/cli /usr/local/bin/pipekit /usr/local/bin/pipekit ``` ## MCP server pointer The CLI also hosts an MCP server. For LLM client integration, see [AI > Setup](/ai/setup). # Cron Workflows Using the Pipekit CLI with CronWorkflows The Pipekit CLI provides `create` (equivalent to submit for regular workflows), `delete`, `suspend`, `resume`, and `update` commands for a CronWorkflow. For further information about CronWorkflows, see [our CronWorkflow documentation](/using-pipekit/pipes/cron). ## Create and update Cron To create a new CronWorkflow on a given cluster: ```bash $> pipekit create cron --cluster-name=clusterB ./path/to/workflow.yaml ``` {% hint style="info" %} This will create a new CronWorkflow and a Pipe based on the CronWorkflow name (part of the metadata inside the YAML). If such a Pipe already exists, a new CronWorkflow manifest will be associated with it as well. {% endhint %} {% hint style="warning" %} Note: You will not be able to create two CronWorkflows with the same name, on the same cluster, in the same namespace. You must therefore check the namespace specified in the meta part of your CronWorkflow yaml. {% endhint %} To update an existing CronWorkflow, on a given cluster: ```bash $> pipekit update cron --cluster-name=clusterB ./path/to/workflow.yaml ``` | Flag | Shorthand | Type | Description | | -------------- | --------- | ------ | -------------------------------------------------------- | | --cluster-name | -c | string | name of the cluster the CronWorkflow lives on (required) | | --namespace | -n | string | namespace in which the CronWorkflow is located | ## Delete Cron To delete a CronWorkflow, from a given cluster, in a given namespace: ```bash $> pipekit delete cron --cluster-name=clusterB --namespace=foo cron-wf-name ``` The argument passed to this command is the name of the CronWorkflow (which should correspond to the Pipe name). | Flag | Shorthand | Type | Description | | -------------- | --------- | ------ | --------------------------------------------------- | | --cluster-name | -c | string | name of the cluster from which to delete (required) | | --namespace | -n | string | namespace in which the CronWorkflow is located | ## Suspend and resume Cron Suspending a CronWorkflow means to stop it from scheduling any new Workflows. The Pipekit CLI lets you suspend a specific CronWorkflow in a given cluster and namespace, without suspending all CronWorkflows in a given Pipe. {% hint style="info" %} See [Disabling a Pipe](/using-pipekit/pipes/edit#disabling-a-pipe) for suspending at the Pipe level in the UI. {% endhint %} To suspend a CronWorkflow, on a given cluster, in a given namespace: ```bash $> pipekit suspend cron --cluster-name=clusterB --namespace=staging cron-wf-name ``` To resume a suspended CronWorkflow, on a given cluster, in a given namespace: ```bash $> pipekit resume cron --cluster-name=clusterB --namespace=staging cron-wf-name ``` The only argument that these commands accept is the name of the CronWorkflow to suspend/resume. | Flag | Shorthand | Type | Description | | -------------- | --------- | ------ | ---------------------------------------------------- | | --cluster-name | -c | string | name of the cluster from which to suspend (required) | | --namespace | -n | string | namespace in which the CronWorkflow is located | {% hint style="warning" %} Note: The only way to suspend and resume a *specific* CronWorkflow, on a given cluster, in a given namespace *without* suspending or resuming the CronWorkflows on other clusters and namespaces is to use the Pipekit CLI. The toggle for a Pipe in the Pipekit web interface will suspend and resume *ALL* CronWorkflows within the Pipe. {% endhint %} ## Trigger Cron To run a CronWorkflow immediately, on a given cluster, in a given namespace: ```bash $> pipekit trigger cron --cluster-name=clusterB --namespace=staging cron-wf-name ``` The only argument that this command accepts is the name of the CronWorkflow to trigger. | Flag | Shorthand | Type | Description | | -------------- | --------- | ------ | ----------------------------------------------------------------------------- | | --cluster-name | -c | string | name of the cluster on which to trigger the run (required) | | --namespace | -n | string | namespace in which the CronWorkflow is located | | --open-ui | | bool | open the Pipekit web interface in your browser for the submitted workflow run | | --wait | -w | bool | wait for the submitted workflow to complete | # MCP Server The MCP server documentation has moved to the AI section. The Pipekit MCP server documentation has moved to [AI > Setup](/ai/setup). Run it with `pipekit mcp`. # REST API How to use the Pipekit REST API The Pipekit REST API lets you submit Argo `Workflow` and `CronWorkflow` types to a Pipekit-managed [Cluster](/concepts/cluster), and query the Pipekit control plane for Pipe and Run state. Every operation the [CLI](/reference/cli), [Python SDK](/reference/python-sdk), and UI perform is exposed here. ## Overview ### Base URL | Deployment | Base URL | | ------------- | ----------------------------------------------------------- | | Pipekit Cloud | `https://pipekit.io/api` | | Self-Hosted | `https:///api` (same path layout, your hostname) | ### Authentication All endpoints require a bearer token in the `Authorization` header: ``` Authorization: Bearer ``` The fastest way to get a token is via the CLI: ```bash pipekit login # one-time pipekit hera # prints a usable bearer token ``` The token is the same one the [Python SDK](/reference/python-sdk) and Hera integrations use. Token lifetime depends on your Organization's session policy; expired tokens return `401 Unauthorized`. ### Identity and access API requests run with the identity of the token's owner. [Access Control](/concepts/access-control) bindings apply: a user without a binding covering the target `{cluster, namespace}` cannot submit there, even with a valid token. ### Submission targets To submit a Workflow or CronWorkflow you'll need: * The bearer token. * The UUID of the target Cluster. List Clusters via `GET /api/users/v1/clusters` or `pipekit list clusters`. ### Error model The API returns standard HTTP status codes plus a JSON body on errors: ```json { "error": "short machine-readable code", "message": "human-readable explanation" } ``` Common codes: * `400 Bad Request`: malformed payload, missing required field. * `401 Unauthorized`: missing, invalid, or expired bearer token. * `403 Forbidden`: token is valid but the user lacks the required access binding. * `404 Not Found`: UUID does not exist (or you don't have access to it; Pipekit doesn't leak existence). * `409 Conflict`: duplicate resource (e.g. CronWorkflow with the same name on the same cluster + namespace). * `5xx`: server-side error. Safe to retry with exponential backoff. ## Operations ### Running a Workflow ## POST /api/users/v1/clusters/{cluster-uuid}/workflows > ```json {"openapi":"3.1.1","paths":{"/api/users/v1/clusters/{cluster-uuid}/workflows":{"post":{"operationId":"CreateWorkflow","responses":{"200":{"description":"OK"}},"requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/v1alpha1.Workflow"}}},"required":true}}}},"components":{"schemas":{"v1alpha1.Workflow":{"required":["metadata","spec"],"properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"$ref":"#/components/schemas/v1alpha1.WorkflowSpec"},"status":{"$ref":"#/components/schemas/v1alpha1.WorkflowStatus"}}},"v1.ObjectMeta":{"description":"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.","properties":{"annotations":{"description":"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations","type":"object","additionalProperties":{"type":"string"}},"clusterName":{"description":"Deprecated: ClusterName is a legacy field that was always cleared by the system and never used; it will be removed completely in 1.25.\n\nThe name in the go struct is changed to help clients detect accidental use.","type":"string"},"creationTimestamp":{"description":"CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"deletionGracePeriodSeconds":{"description":"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.","type":"integer","format":"int64"},"deletionTimestamp":{"description":"DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"finalizers":{"description":"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.","type":"array","items":{"type":"string"}},"generateName":{"description":"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency","type":"string"},"generation":{"description":"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.","type":"integer","format":"int64"},"labels":{"description":"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels","type":"object","additionalProperties":{"type":"string"}},"managedFields":{"description":"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.","type":"array","items":{"$ref":"#/components/schemas/v1.ManagedFieldsEntry"}},"name":{"description":"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"namespace":{"description":"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces","type":"string"},"ownerReferences":{"description":"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.","type":"array","items":{"$ref":"#/components/schemas/v1.OwnerReference"}},"resourceVersion":{"description":"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency","type":"string"},"selfLink":{"description":"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.","type":"string"},"uid":{"description":"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}},"v1.ManagedFieldsEntry":{"description":"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.","properties":{"apiVersion":{"description":"APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.","type":"string"},"fieldsType":{"description":"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"","type":"string"},"fieldsV1":{"description":"FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type.","$ref":"#/components/schemas/v1.FieldsV1"},"manager":{"description":"Manager is an identifier of the workflow managing these fields.","type":"string"},"operation":{"description":"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.","type":"string"},"subresource":{"description":"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.","type":"string"},"time":{"description":"Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over.","$ref":"#/components/schemas/v1.Time"}}},"v1.FieldsV1":{"description":"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff"},"v1.OwnerReference":{"description":"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.","required":["apiVersion","kind","name","uid"],"properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"blockOwnerDeletion":{"description":"If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.","type":"boolean"},"controller":{"description":"If true, this reference points to the managing controller.","type":"boolean"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"uid":{"description":"UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1alpha1.WorkflowSpec":{"properties":{"activeDeadlineSeconds":{"type":"integer","format":"int64"},"affinity":{"$ref":"#/components/schemas/v1.Affinity"},"archiveLogs":{"type":"boolean"},"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.WorkflowLevelArtifactGC"},"artifactRepositoryRef":{"$ref":"#/components/schemas/v1alpha1.ArtifactRepositoryRef"},"automountServiceAccountToken":{"type":"boolean"},"dnsConfig":{"$ref":"#/components/schemas/v1.PodDNSConfig"},"dnsPolicy":{"type":"string"},"entrypoint":{"type":"string"},"executor":{"$ref":"#/components/schemas/v1alpha1.ExecutorConfig"},"hooks":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LifecycleHook"}},"hostAliases":{"type":"array","items":{"$ref":"#/components/schemas/v1.HostAlias"}},"hostNetwork":{"type":"boolean"},"imagePullSecrets":{"type":"array","items":{"$ref":"#/components/schemas/v1.LocalObjectReference"}},"metrics":{"$ref":"#/components/schemas/v1alpha1.Metrics"},"nodeSelector":{"type":"object","additionalProperties":{"type":"string"}},"onExit":{"type":"string"},"parallelism":{"type":"integer","format":"int64"},"podDisruptionBudget":{"$ref":"#/components/schemas/v1.PodDisruptionBudgetSpec"},"podGC":{"$ref":"#/components/schemas/v1alpha1.PodGC"},"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"podPriority":{"type":"integer","format":"int32"},"podPriorityClassName":{"type":"string"},"podSpecPatch":{"type":"string"},"priority":{"type":"integer","format":"int32"},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.RetryStrategy"},"schedulerName":{"type":"string"},"securityContext":{"$ref":"#/components/schemas/v1.PodSecurityContext"},"serviceAccountName":{"type":"string"},"shutdown":{"type":"string"},"suspend":{"type":"boolean"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.Synchronization"},"templateDefaults":{"$ref":"#/components/schemas/v1alpha1.Template"},"templates":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Template"}},"tolerations":{"type":"array","items":{"$ref":"#/components/schemas/v1.Toleration"}},"ttlStrategy":{"$ref":"#/components/schemas/v1alpha1.TTLStrategy"},"volumeClaimGC":{"$ref":"#/components/schemas/v1alpha1.VolumeClaimGC"},"volumeClaimTemplates":{"type":"array","items":{"$ref":"#/components/schemas/v1.PersistentVolumeClaim"}},"volumes":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}},"workflowMetadata":{"$ref":"#/components/schemas/v1alpha1.WorkflowMetadata"},"workflowTemplateRef":{"$ref":"#/components/schemas/v1alpha1.WorkflowTemplateRef"}}},"v1.Affinity":{"description":"Affinity is a group of affinity scheduling rules.","properties":{"nodeAffinity":{"description":"Describes node affinity scheduling rules for the pod.","$ref":"#/components/schemas/v1.NodeAffinity"},"podAffinity":{"description":"Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAffinity"},"podAntiAffinity":{"description":"Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAntiAffinity"}}},"v1.NodeAffinity":{"description":"Node affinity is a group of node affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.PreferredSchedulingTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.","$ref":"#/components/schemas/v1.NodeSelector"}}},"v1.PreferredSchedulingTerm":{"description":"An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).","required":["weight","preference"],"properties":{"preference":{"description":"A node selector term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.NodeSelectorTerm"},"weight":{"description":"Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.NodeSelectorTerm":{"description":"A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.","properties":{"matchExpressions":{"description":"A list of node selector requirements by node's labels.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}},"matchFields":{"description":"A list of node selector requirements by node's fields.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}}}},"v1.NodeSelectorRequirement":{"description":"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"The label key that the selector applies to.","type":"string"},"operator":{"description":"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.","type":"string"},"values":{"description":"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.NodeSelector":{"description":"A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.","required":["nodeSelectorTerms"],"properties":{"nodeSelectorTerms":{"description":"Required. A list of node selector terms. The terms are ORed.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorTerm"}}}},"v1.PodAffinity":{"description":"Pod affinity is a group of inter pod affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1.WeightedPodAffinityTerm":{"description":"The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)","required":["weight","podAffinityTerm"],"properties":{"podAffinityTerm":{"description":"Required. A pod affinity term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.PodAffinityTerm"},"weight":{"description":"weight associated with matching the corresponding podAffinityTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.PodAffinityTerm":{"description":"Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running","required":["topologyKey"],"properties":{"labelSelector":{"description":"A label query over a set of resources, in this case pods.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaceSelector":{"description":"A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means \"this pod's namespace\". An empty selector ({}) matches all namespaces.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaces":{"description":"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".","type":"array","items":{"type":"string"}},"topologyKey":{"description":"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.","type":"string"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.PodAntiAffinity":{"description":"Pod anti affinity is a group of inter pod anti affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1alpha1.Arguments":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Artifact":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.Parameter":{"required":["name"],"properties":{"default":{"type":"string"},"description":{"type":"string"},"enum":{"type":"array","items":{"type":"string"}},"globalName":{"type":"string"},"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.ValueFrom"}}},"v1alpha1.ValueFrom":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"default":{"type":"string"},"event":{"type":"string"},"expression":{"type":"string"},"jqFilter":{"type":"string"},"jsonPath":{"type":"string"},"parameter":{"type":"string"},"path":{"type":"string"},"supplied":{"$ref":"#/components/schemas/v1alpha1.SuppliedValueFrom"}}},"v1alpha1.SuppliedValueFrom":{},"v1alpha1.WorkflowLevelArtifactGC":{"properties":{"forceFinalizerRemoval":{"type":"boolean"},"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"podSpecPatch":{"type":"string"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.ArtifactRepositoryRef":{"properties":{"configMap":{"type":"string"},"key":{"type":"string"}}},"v1.PodDNSConfig":{"description":"PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy.","properties":{"nameservers":{"description":"A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed.","type":"array","items":{"type":"string"}},"options":{"description":"A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy.","type":"array","items":{"$ref":"#/components/schemas/v1.PodDNSConfigOption"}},"searches":{"description":"A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed.","type":"array","items":{"type":"string"}}}},"v1.PodDNSConfigOption":{"description":"PodDNSConfigOption defines DNS resolver options of a pod.","properties":{"name":{"description":"Required.","type":"string"},"value":{"type":"string"}}},"v1alpha1.ExecutorConfig":{"properties":{"serviceAccountName":{"type":"string"}}},"v1alpha1.LifecycleHook":{"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"expression":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"}}},"v1alpha1.TemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"},"template":{"type":"string"}}},"v1.HostAlias":{"description":"HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.","properties":{"hostnames":{"description":"Hostnames for the above IP address.","type":"array","items":{"type":"string"}},"ip":{"description":"IP address of the host file entry.","type":"string"}}},"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}},"v1alpha1.Metrics":{"required":["prometheus"],"properties":{"prometheus":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Prometheus"}}}},"v1alpha1.Prometheus":{"required":["name","help"],"properties":{"counter":{"$ref":"#/components/schemas/v1alpha1.Counter"},"gauge":{"$ref":"#/components/schemas/v1alpha1.Gauge"},"help":{"type":"string"},"histogram":{"$ref":"#/components/schemas/v1alpha1.Histogram"},"labels":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MetricLabel"}},"name":{"type":"string"},"when":{"type":"string"}}},"v1alpha1.Counter":{"required":["value"],"properties":{"value":{"type":"string"}}},"v1alpha1.Gauge":{"required":["value","realtime"],"properties":{"operation":{"type":"string"},"realtime":{"type":"boolean"},"value":{"type":"string"}}},"v1alpha1.Histogram":{"required":["value","buckets"],"properties":{"buckets":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Amount"}},"value":{"type":"string"}}},"v1alpha1.Amount":{},"v1alpha1.MetricLabel":{"required":["key","value"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1.PodDisruptionBudgetSpec":{"description":"PodDisruptionBudgetSpec is a description of a PodDisruptionBudget.","properties":{"maxUnavailable":{"description":"An eviction is allowed if at most \"maxUnavailable\" pods selected by \"selector\" are unavailable after the eviction, i.e. even in absence of the evicted pod. For example, one can prevent all voluntary evictions by specifying 0. This is a mutually exclusive setting with \"minAvailable\".","$ref":"#/components/schemas/intstr.IntOrString"},"minAvailable":{"description":"An eviction is allowed if at least \"minAvailable\" pods selected by \"selector\" will still be available after the eviction, i.e. even in the absence of the evicted pod. So for example you can prevent all voluntary evictions by specifying \"100%\".","$ref":"#/components/schemas/intstr.IntOrString"},"selector":{"description":"Label query over pods whose evictions are managed by the disruption budget. A null selector will match no pods, while an empty ({}) selector will select all pods within the namespace.","$ref":"#/components/schemas/v1.LabelSelector"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}},"v1alpha1.PodGC":{"properties":{"deleteDelayDuration":{"type":"string"},"labelSelector":{"$ref":"#/components/schemas/v1.LabelSelector"},"strategy":{"type":"string"}}},"v1alpha1.RetryStrategy":{"properties":{"affinity":{"$ref":"#/components/schemas/v1alpha1.RetryAffinity"},"backoff":{"$ref":"#/components/schemas/v1alpha1.Backoff"},"expression":{"type":"string"},"limit":{"$ref":"#/components/schemas/intstr.IntOrString"},"retryPolicy":{"type":"string"}}},"v1alpha1.RetryAffinity":{"properties":{"nodeAntiAffinity":{"$ref":"#/components/schemas/v1alpha1.RetryNodeAntiAffinity"}}},"v1alpha1.RetryNodeAntiAffinity":{},"v1alpha1.Backoff":{"properties":{"duration":{"type":"string"},"factor":{"$ref":"#/components/schemas/intstr.IntOrString"},"maxDuration":{"type":"string"}}},"v1.PodSecurityContext":{"description":"PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.","properties":{"fsGroup":{"description":"A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\n\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw ","type":"integer","format":"int64"},"fsGroupChangePolicy":{"description":"fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \"OnRootMismatch\" and \"Always\". If not specified, \"Always\" is used. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"supplementalGroups":{"description":"A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"type":"integer","format":"int64"}},"sysctls":{"description":"Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"$ref":"#/components/schemas/v1.Sysctl"}},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.SELinuxOptions":{"description":"SELinuxOptions are the labels to be applied to the container","properties":{"level":{"description":"Level is SELinux level label that applies to the container.","type":"string"},"role":{"description":"Role is a SELinux role label that applies to the container.","type":"string"},"type":{"description":"Type is a SELinux type label that applies to the container.","type":"string"},"user":{"description":"User is a SELinux user label that applies to the container.","type":"string"}}},"v1.SeccompProfile":{"description":"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.","required":["type"],"properties":{"localhostProfile":{"description":"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is \"Localhost\".","type":"string"},"type":{"description":"type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.","type":"string"}}},"v1.Sysctl":{"description":"Sysctl defines a kernel parameter to be set","required":["name","value"],"properties":{"name":{"description":"Name of a property to set","type":"string"},"value":{"description":"Value of a property to set","type":"string"}}},"v1.WindowsSecurityContextOptions":{"description":"WindowsSecurityContextOptions contain Windows-specific options and credentials.","properties":{"gmsaCredentialSpec":{"description":"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.","type":"string"},"gmsaCredentialSpecName":{"description":"GMSACredentialSpecName is the name of the GMSA credential spec to use.","type":"string"},"hostProcess":{"description":"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.","type":"boolean"},"runAsUserName":{"description":"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"string"}}},"v1alpha1.Synchronization":{"properties":{"mutex":{"$ref":"#/components/schemas/v1alpha1.Mutex"},"semaphore":{"$ref":"#/components/schemas/v1alpha1.SemaphoreRef"}}},"v1alpha1.Mutex":{"properties":{"name":{"type":"string"},"namespace":{"type":"string"}}},"v1alpha1.SemaphoreRef":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"namespace":{"type":"string"}}},"v1alpha1.Template":{"properties":{"activeDeadlineSeconds":{"$ref":"#/components/schemas/intstr.IntOrString"},"affinity":{"$ref":"#/components/schemas/v1.Affinity"},"archiveLocation":{"$ref":"#/components/schemas/v1alpha1.ArtifactLocation"},"automountServiceAccountToken":{"type":"boolean"},"container":{"$ref":"#/components/schemas/v1.Container"},"containerSet":{"$ref":"#/components/schemas/v1alpha1.ContainerSetTemplate"},"daemon":{"type":"boolean"},"dag":{"$ref":"#/components/schemas/v1alpha1.DAGTemplate"},"data":{"$ref":"#/components/schemas/v1alpha1.Data"},"executor":{"$ref":"#/components/schemas/v1alpha1.ExecutorConfig"},"failFast":{"type":"boolean"},"hostAliases":{"type":"array","items":{"$ref":"#/components/schemas/v1.HostAlias"}},"http":{"$ref":"#/components/schemas/v1alpha1.HTTP"},"initContainers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"inputs":{"$ref":"#/components/schemas/v1alpha1.Inputs"},"memoize":{"$ref":"#/components/schemas/v1alpha1.Memoize"},"metadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"metrics":{"$ref":"#/components/schemas/v1alpha1.Metrics"},"name":{"type":"string"},"nodeSelector":{"type":"object","additionalProperties":{"type":"string"}},"outputs":{"$ref":"#/components/schemas/v1alpha1.Outputs"},"parallelism":{"type":"integer","format":"int64"},"plugin":{"$ref":"#/components/schemas/v1alpha1.Plugin"},"podSpecPatch":{"type":"string"},"priority":{"type":"integer","format":"int32"},"priorityClassName":{"type":"string"},"resource":{"$ref":"#/components/schemas/v1alpha1.ResourceTemplate"},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.RetryStrategy"},"schedulerName":{"type":"string"},"script":{"$ref":"#/components/schemas/v1alpha1.ScriptTemplate"},"securityContext":{"$ref":"#/components/schemas/v1.PodSecurityContext"},"serviceAccountName":{"type":"string"},"sidecars":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"steps":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ParallelSteps"}},"suspend":{"$ref":"#/components/schemas/v1alpha1.SuspendTemplate"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.Synchronization"},"timeout":{"type":"string"},"tolerations":{"type":"array","items":{"$ref":"#/components/schemas/v1.Toleration"}},"volumes":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}}}},"v1alpha1.ArtifactLocation":{"properties":{"archiveLogs":{"type":"boolean"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"}}},"v1.Container":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1.EnvVar":{"description":"EnvVar represents an environment variable present in a Container.","required":["name"],"properties":{"name":{"description":"Name of the environment variable. Must be a C_IDENTIFIER.","type":"string"},"value":{"description":"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".","type":"string"},"valueFrom":{"description":"Source for the environment variable's value. Cannot be used if value is not empty.","$ref":"#/components/schemas/v1.EnvVarSource"}}},"v1.EnvVarSource":{"description":"EnvVarSource represents a source for the value of an EnvVar.","properties":{"configMapKeyRef":{"description":"Selects a key of a ConfigMap.","$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"fieldRef":{"description":"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"},"secretKeyRef":{"description":"Selects a key of a secret in the pod's namespace","$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.EnvFromSource":{"description":"EnvFromSource represents the source of a set of ConfigMaps","properties":{"configMapRef":{"description":"The ConfigMap to select from","$ref":"#/components/schemas/v1.ConfigMapEnvSource"},"prefix":{"description":"An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.","type":"string"},"secretRef":{"description":"The Secret to select from","$ref":"#/components/schemas/v1.SecretEnvSource"}}},"v1.ConfigMapEnvSource":{"description":"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap must be defined","type":"boolean"}}},"v1.SecretEnvSource":{"description":"SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret must be defined","type":"boolean"}}},"v1.Lifecycle":{"description":"Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.","properties":{"postStart":{"description":"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"},"preStop":{"description":"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"}}},"v1.LifecycleHandler":{"description":"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"tcpSocket":{"description":"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.","$ref":"#/components/schemas/v1.TCPSocketAction"}}},"v1.ExecAction":{"description":"ExecAction describes a \"run in container\" action.","properties":{"command":{"description":"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.","type":"array","items":{"type":"string"}}}},"v1.HTTPGetAction":{"description":"HTTPGetAction describes an action based on HTTP Get requests.","required":["port"],"properties":{"host":{"description":"Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.","type":"string"},"httpHeaders":{"description":"Custom headers to set in the request. HTTP allows repeated headers.","type":"array","items":{"$ref":"#/components/schemas/v1.HTTPHeader"}},"path":{"description":"Path to access on the HTTP server.","type":"string"},"port":{"description":"Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"},"scheme":{"description":"Scheme to use for connecting to the host. Defaults to HTTP.","type":"string"}}},"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}},"v1.TCPSocketAction":{"description":"TCPSocketAction describes an action based on opening a socket","required":["port"],"properties":{"host":{"description":"Optional: Host name to connect to, defaults to the pod IP.","type":"string"},"port":{"description":"Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"}}},"v1.Probe":{"description":"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"failureThreshold":{"description":"Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.","type":"integer","format":"int32"},"grpc":{"description":"GRPC specifies an action involving a GRPC port. This is a beta field and requires enabling GRPCContainerProbe feature gate.","$ref":"#/components/schemas/v1.GRPCAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"initialDelaySeconds":{"description":"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"},"periodSeconds":{"description":"How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.","type":"integer","format":"int32"},"successThreshold":{"description":"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.","type":"integer","format":"int32"},"tcpSocket":{"description":"TCPSocket specifies an action involving a TCP port.","$ref":"#/components/schemas/v1.TCPSocketAction"},"terminationGracePeriodSeconds":{"description":"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.","type":"integer","format":"int64"},"timeoutSeconds":{"description":"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"}}},"v1.GRPCAction":{"required":["port","service"],"properties":{"port":{"description":"Port number of the gRPC service. Number must be in the range 1 to 65535.","type":"integer","format":"int32"},"service":{"description":"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.","type":"string"}}},"v1.ContainerPort":{"description":"ContainerPort represents a network port in a single container.","required":["containerPort"],"properties":{"containerPort":{"description":"Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.","type":"integer","format":"int32"},"hostIP":{"description":"What host IP to bind the external port to.","type":"string"},"hostPort":{"description":"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.","type":"integer","format":"int32"},"name":{"description":"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.","type":"string"},"protocol":{"description":"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"v1.SecurityContext":{"description":"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.","properties":{"allowPrivilegeEscalation":{"description":"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"capabilities":{"description":"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.Capabilities"},"privileged":{"description":"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"procMount":{"description":"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"readOnlyRootFilesystem":{"description":"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Capabilities":{"description":"Adds and removes POSIX capabilities from running containers.","properties":{"add":{"description":"Added capabilities","type":"array","items":{"type":"string"}},"drop":{"description":"Removed capabilities","type":"array","items":{"type":"string"}}}},"v1.VolumeDevice":{"description":"volumeDevice describes a mapping of a raw block device within a container.","required":["name","devicePath"],"properties":{"devicePath":{"description":"devicePath is the path inside of the container that the device will be mapped to.","type":"string"},"name":{"description":"name must match the name of a persistentVolumeClaim in the pod","type":"string"}}},"v1.VolumeMount":{"description":"VolumeMount describes a mounting of a Volume within a container.","required":["name","mountPath"],"properties":{"mountPath":{"description":"Path within the container at which the volume should be mounted. Must not contain ':'.","type":"string"},"mountPropagation":{"description":"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10.","type":"string"},"name":{"description":"This must match the Name of a Volume.","type":"string"},"readOnly":{"description":"Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.","type":"boolean"},"subPath":{"description":"Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).","type":"string"},"subPathExpr":{"description":"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.","type":"string"}}},"v1alpha1.ContainerSetTemplate":{"required":["containers"],"properties":{"containers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ContainerNode"}},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.ContainerSetRetryStrategy"},"volumeMounts":{"type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}}}},"v1alpha1.ContainerNode":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"dependencies":{"type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.ContainerSetRetryStrategy":{"required":["retries"],"properties":{"duration":{"type":"string"},"retries":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"v1alpha1.DAGTemplate":{"required":["tasks"],"properties":{"failFast":{"type":"boolean"},"target":{"type":"string"},"tasks":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.DAGTask"}}}},"v1alpha1.DAGTask":{"required":["name"],"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"continueOn":{"$ref":"#/components/schemas/v1alpha1.ContinueOn"},"dependencies":{"type":"array","items":{"type":"string"}},"depends":{"type":"string"},"hooks":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LifecycleHook"}},"inline":{"$ref":"#/components/schemas/v1alpha1.Template"},"name":{"type":"string"},"onExit":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"},"when":{"type":"string"},"withItems":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Item"}},"withParam":{"type":"string"},"withSequence":{"$ref":"#/components/schemas/v1alpha1.Sequence"}}},"v1alpha1.ContinueOn":{"properties":{"error":{"type":"boolean"},"failed":{"type":"boolean"}}},"v1alpha1.Item":{},"v1alpha1.Sequence":{"properties":{"count":{"$ref":"#/components/schemas/intstr.IntOrString"},"end":{"$ref":"#/components/schemas/intstr.IntOrString"},"format":{"type":"string"},"start":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"v1alpha1.Data":{"required":["source","transformation"],"properties":{"source":{"$ref":"#/components/schemas/v1alpha1.DataSource"},"transformation":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.TransformationStep"}}}},"v1alpha1.DataSource":{"properties":{"artifactPaths":{"$ref":"#/components/schemas/v1alpha1.ArtifactPaths"}}},"v1alpha1.ArtifactPaths":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.TransformationStep":{"required":["expression"],"properties":{"expression":{"type":"string"}}},"v1alpha1.HTTP":{"required":["url"],"properties":{"body":{"type":"string"},"bodyFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPBodySource"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.HTTPHeader"}},"insecureSkipVerify":{"type":"boolean"},"method":{"type":"string"},"successCondition":{"type":"string"},"timeoutSeconds":{"type":"integer","format":"int64"},"url":{"type":"string"}}},"v1alpha1.HTTPBodySource":{"properties":{"bytes":{"type":"string"}}},"v1alpha1.HTTPHeader":{"required":["name"],"properties":{"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPHeaderSource"}}},"v1alpha1.HTTPHeaderSource":{"properties":{"secretKeyRef":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.UserContainer":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"mirrorVolumeMounts":{"type":"boolean"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.Inputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Memoize":{"required":["key","cache","maxAge"],"properties":{"cache":{"$ref":"#/components/schemas/v1alpha1.Cache"},"key":{"type":"string"},"maxAge":{"type":"string"}}},"v1alpha1.Cache":{"required":["configMap"],"properties":{"configMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"}}},"v1alpha1.Outputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"exitCode":{"type":"string"},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}},"result":{"type":"string"}}},"v1alpha1.Plugin":{},"v1alpha1.ResourceTemplate":{"required":["action"],"properties":{"action":{"type":"string"},"failureCondition":{"type":"string"},"flags":{"type":"array","items":{"type":"string"}},"manifest":{"type":"string"},"manifestFrom":{"$ref":"#/components/schemas/v1alpha1.ManifestFrom"},"mergeStrategy":{"type":"string"},"setOwnerReference":{"type":"boolean"},"successCondition":{"type":"string"}}},"v1alpha1.ManifestFrom":{"required":["artifact"],"properties":{"artifact":{"$ref":"#/components/schemas/v1alpha1.Artifact"}}},"v1alpha1.ScriptTemplate":{"description":"A single application container that you want to run within a pod.","required":["name","source"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"source":{"type":"string"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.ParallelSteps":{},"v1alpha1.SuspendTemplate":{"properties":{"duration":{"type":"string"}}},"v1.Toleration":{"description":"The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .","properties":{"effect":{"description":"Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.","type":"string"},"key":{"description":"Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.","type":"string"},"operator":{"description":"Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.","type":"string"},"tolerationSeconds":{"description":"TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.","type":"integer","format":"int64"},"value":{"description":"Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.","type":"string"}}},"v1.Volume":{"description":"Volume represents a named volume in a pod that may be accessed by any container in the pod.","required":["name"],"properties":{"awsElasticBlockStore":{"description":"awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","$ref":"#/components/schemas/v1.AWSElasticBlockStoreVolumeSource"},"azureDisk":{"description":"azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureDiskVolumeSource"},"azureFile":{"description":"azureFile represents an Azure File Service mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureFileVolumeSource"},"cephfs":{"description":"cephFS represents a Ceph FS mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.CephFSVolumeSource"},"cinder":{"description":"cinder represents a cinder volume attached and mounted on kubelets host machine. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","$ref":"#/components/schemas/v1.CinderVolumeSource"},"configMap":{"description":"configMap represents a configMap that should populate this volume","$ref":"#/components/schemas/v1.ConfigMapVolumeSource"},"csi":{"description":"csi (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers (Beta feature).","$ref":"#/components/schemas/v1.CSIVolumeSource"},"downwardAPI":{"description":"downwardAPI represents downward API about the pod that should populate this volume","$ref":"#/components/schemas/v1.DownwardAPIVolumeSource"},"emptyDir":{"description":"emptyDir represents a temporary directory that shares a pod's lifetime. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","$ref":"#/components/schemas/v1.EmptyDirVolumeSource"},"ephemeral":{"description":"ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed.\n\nUse this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity\n tracking are needed,\nc) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through\n a PersistentVolumeClaim (see EphemeralVolumeSource for more\n information on the connection between this volume type\n and PersistentVolumeClaim).\n\nUse PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod.\n\nUse CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information.\n\nA pod can use both types of ephemeral volumes and persistent volumes at the same time.","$ref":"#/components/schemas/v1.EphemeralVolumeSource"},"fc":{"description":"fc represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.","$ref":"#/components/schemas/v1.FCVolumeSource"},"flexVolume":{"description":"flexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","$ref":"#/components/schemas/v1.FlexVolumeSource"},"flocker":{"description":"flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running","$ref":"#/components/schemas/v1.FlockerVolumeSource"},"gcePersistentDisk":{"description":"gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","$ref":"#/components/schemas/v1.GCEPersistentDiskVolumeSource"},"gitRepo":{"description":"gitRepo represents a git repository at a particular revision. DEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","$ref":"#/components/schemas/v1.GitRepoVolumeSource"},"glusterfs":{"description":"glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/glusterfs/README.md","$ref":"#/components/schemas/v1.GlusterfsVolumeSource"},"hostPath":{"description":"hostPath represents a pre-existing file or directory on the host machine that is directly exposed to the container. This is generally used for system agents or other privileged things that are allowed to see the host machine. Most containers will NOT need this. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","$ref":"#/components/schemas/v1.HostPathVolumeSource"},"iscsi":{"description":"iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://examples.k8s.io/volumes/iscsi/README.md","$ref":"#/components/schemas/v1.ISCSIVolumeSource"},"name":{"description":"name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"nfs":{"description":"nfs represents an NFS mount on the host that shares a pod's lifetime More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","$ref":"#/components/schemas/v1.NFSVolumeSource"},"persistentVolumeClaim":{"description":"persistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimVolumeSource"},"photonPersistentDisk":{"description":"photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PhotonPersistentDiskVolumeSource"},"portworxVolume":{"description":"portworxVolume represents a portworx volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PortworxVolumeSource"},"projected":{"description":"projected items for all in one resources secrets, configmaps, and downward API","$ref":"#/components/schemas/v1.ProjectedVolumeSource"},"quobyte":{"description":"quobyte represents a Quobyte mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.QuobyteVolumeSource"},"rbd":{"description":"rbd represents a Rados Block Device mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/rbd/README.md","$ref":"#/components/schemas/v1.RBDVolumeSource"},"scaleIO":{"description":"scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.ScaleIOVolumeSource"},"secret":{"description":"secret represents a secret that should populate this volume. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","$ref":"#/components/schemas/v1.SecretVolumeSource"},"storageos":{"description":"storageOS represents a StorageOS volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.StorageOSVolumeSource"},"vsphereVolume":{"description":"vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.VsphereVirtualDiskVolumeSource"}}},"v1.AWSElasticBlockStoreVolumeSource":{"description":"Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).","type":"integer","format":"int32"},"readOnly":{"description":"readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"boolean"},"volumeID":{"description":"volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"}}},"v1.AzureDiskVolumeSource":{"description":"AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","required":["diskName","diskURI"],"properties":{"cachingMode":{"description":"cachingMode is the Host Caching mode: None, Read Only, Read Write.","type":"string"},"diskName":{"description":"diskName is the Name of the data disk in the blob storage","type":"string"},"diskURI":{"description":"diskURI is the URI of data disk in the blob storage","type":"string"},"fsType":{"description":"fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"kind":{"description":"kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"}}},"v1.AzureFileVolumeSource":{"description":"AzureFile represents an Azure File Service mount on the host and bind mount to the pod.","required":["secretName","shareName"],"properties":{"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretName":{"description":"secretName is the name of secret that contains Azure Storage Account Name and Key","type":"string"},"shareName":{"description":"shareName is the azure share Name","type":"string"}}},"v1.CephFSVolumeSource":{"description":"Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.","required":["monitors"],"properties":{"monitors":{"description":"monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"path":{"description":"path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /","type":"string"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"boolean"},"secretFile":{"description":"secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"},"secretRef":{"description":"secretRef is Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"}}},"v1.CinderVolumeSource":{"description":"Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"boolean"},"secretRef":{"description":"secretRef is optional: points to a secret object containing parameters used to connect to OpenStack.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeID":{"description":"volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"}}},"v1.ConfigMapVolumeSource":{"description":"Adapts a ConfigMap into a volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.KeyToPath":{"description":"Maps a string key to a path within a volume.","required":["key","path"],"properties":{"key":{"description":"key is the key to project.","type":"string"},"mode":{"description":"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.","type":"string"}}},"v1.CSIVolumeSource":{"description":"Represents a source location of a volume to mount, managed by an external CSI driver","required":["driver"],"properties":{"driver":{"description":"driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.","type":"string"},"fsType":{"description":"fsType to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.","type":"string"},"nodePublishSecretRef":{"description":"nodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secret references are passed.","$ref":"#/components/schemas/v1.LocalObjectReference"},"readOnly":{"description":"readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).","type":"boolean"},"volumeAttributes":{"description":"volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.","type":"object","additionalProperties":{"type":"string"}}}},"v1.DownwardAPIVolumeSource":{"description":"DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"Items is a list of downward API volume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.DownwardAPIVolumeFile":{"description":"DownwardAPIVolumeFile represents information to create the file containing the pod field","required":["path"],"properties":{"fieldRef":{"description":"Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"mode":{"description":"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'","type":"string"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"}}},"v1.EmptyDirVolumeSource":{"description":"Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.","properties":{"medium":{"description":"medium represents what type of storage medium should back this directory. The default is \"\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","type":"string"},"sizeLimit":{"description":"sizeLimit is the total amount of local storage required for this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. The default is nil which means that the limit is undefined. More info: http://kubernetes.io/docs/user-guide/volumes#emptydir","$ref":"#/components/schemas/resource.Quantity"}}},"v1.EphemeralVolumeSource":{"description":"Represents an ephemeral volume that is handled by a normal storage driver.","properties":{"volumeClaimTemplate":{"description":"Will be used to create a stand-alone PVC to provision the volume. The pod in which this EphemeralVolumeSource is embedded will be the owner of the PVC, i.e. the PVC will be deleted together with the pod. The name of the PVC will be `-` where `` is the name from the `PodSpec.Volumes` array entry. Pod validation will reject the pod if the concatenated name is not valid for a PVC (for example, too long).\n\nAn existing PVC with that name that is not owned by the pod will *not* be used for the pod to avoid using an unrelated volume by mistake. Starting the pod is then blocked until the unrelated PVC is removed. If such a pre-created PVC is meant to be used by the pod, the PVC has to updated with an owner reference to the pod once the pod exists. Normally this should not be necessary, but it may be useful when manually reconstructing a broken cluster.\n\nThis field is read-only and no changes will be made by Kubernetes to the PVC after it has been created.\n\nRequired, must not be nil.","$ref":"#/components/schemas/v1.PersistentVolumeClaimTemplate"}}},"v1.PersistentVolumeClaimTemplate":{"description":"PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.","required":["spec"],"properties":{"metadata":{"description":"May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"The specification for the PersistentVolumeClaim. The entire content is copied unchanged into the PVC that gets created from this template. The same fields as in a PersistentVolumeClaim are also valid here.","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"}}},"v1.PersistentVolumeClaimSpec":{"description":"PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes","properties":{"accessModes":{"description":"accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"dataSource":{"description":"dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"dataSourceRef":{"description":"dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"resources":{"description":"resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources","$ref":"#/components/schemas/v1.ResourceRequirements"},"selector":{"description":"selector is a label query over volumes to consider for binding.","$ref":"#/components/schemas/v1.LabelSelector"},"storageClassName":{"description":"storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1","type":"string"},"volumeMode":{"description":"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.","type":"string"},"volumeName":{"description":"volumeName is the binding reference to the PersistentVolume backing this claim.","type":"string"}}},"v1.TypedLocalObjectReference":{"description":"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.","required":["apiGroup","kind","name"],"properties":{"apiGroup":{"description":"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.","type":"string"},"kind":{"description":"Kind is the type of resource being referenced","type":"string"},"name":{"description":"Name is the name of resource being referenced","type":"string"}}},"v1.FCVolumeSource":{"description":"Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"lun":{"description":"lun is Optional: FC target lun number","type":"integer","format":"int32"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"targetWWNs":{"description":"targetWWNs is Optional: FC target worldwide names (WWNs)","type":"array","items":{"type":"string"}},"wwids":{"description":"wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.","type":"array","items":{"type":"string"}}}},"v1.FlexVolumeSource":{"description":"FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","required":["driver"],"properties":{"driver":{"description":"driver is the name of the driver to use for this volume.","type":"string"},"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.","type":"string"},"options":{"description":"options is Optional: this field holds extra command options if any.","type":"object","additionalProperties":{"type":"string"}},"readOnly":{"description":"readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef is Optional: secretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts.","$ref":"#/components/schemas/v1.LocalObjectReference"}}},"v1.FlockerVolumeSource":{"description":"Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.","properties":{"datasetName":{"description":"datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated","type":"string"},"datasetUUID":{"description":"datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset","type":"string"}}},"v1.GCEPersistentDiskVolumeSource":{"description":"Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.","required":["pdName"],"properties":{"fsType":{"description":"fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"integer","format":"int32"},"pdName":{"description":"pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"boolean"}}},"v1.GitRepoVolumeSource":{"description":"Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","required":["repository"],"properties":{"directory":{"description":"directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.","type":"string"},"repository":{"description":"repository is the URL","type":"string"},"revision":{"description":"revision is the commit hash for the specified revision.","type":"string"}}},"v1.GlusterfsVolumeSource":{"description":"Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.","required":["endpoints","path"],"properties":{"endpoints":{"description":"endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"path":{"description":"path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"readOnly":{"description":"readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"boolean"}}},"v1.HostPathVolumeSource":{"description":"Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.","required":["path"],"properties":{"path":{"description":"path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"},"type":{"description":"type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"}}},"v1.ISCSIVolumeSource":{"description":"Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.","required":["targetPortal","iqn","lun"],"properties":{"chapAuthDiscovery":{"description":"chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication","type":"boolean"},"chapAuthSession":{"description":"chapAuthSession defines whether support iSCSI Session CHAP authentication","type":"boolean"},"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi","type":"string"},"initiatorName":{"description":"initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.","type":"string"},"iqn":{"description":"iqn is the target iSCSI Qualified Name.","type":"string"},"iscsiInterface":{"description":"iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).","type":"string"},"lun":{"description":"lun represents iSCSI Target Lun number.","type":"integer","format":"int32"},"portals":{"description":"portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"array","items":{"type":"string"}},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.","type":"boolean"},"secretRef":{"description":"secretRef is the CHAP Secret for iSCSI target and initiator authentication","$ref":"#/components/schemas/v1.LocalObjectReference"},"targetPortal":{"description":"targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"string"}}},"v1.NFSVolumeSource":{"description":"Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.","required":["server","path"],"properties":{"path":{"description":"path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"},"readOnly":{"description":"readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"boolean"},"server":{"description":"server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"}}},"v1.PersistentVolumeClaimVolumeSource":{"description":"PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).","required":["claimName"],"properties":{"claimName":{"description":"claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","type":"string"},"readOnly":{"description":"readOnly Will force the ReadOnly setting in VolumeMounts. Default false.","type":"boolean"}}},"v1.PhotonPersistentDiskVolumeSource":{"description":"Represents a Photon Controller persistent disk resource.","required":["pdID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"pdID":{"description":"pdID is the ID that identifies Photon Controller persistent disk","type":"string"}}},"v1.PortworxVolumeSource":{"description":"PortworxVolumeSource represents a Portworx volume resource.","required":["volumeID"],"properties":{"fsType":{"description":"fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"volumeID":{"description":"volumeID uniquely identifies a Portworx volume","type":"string"}}},"v1.ProjectedVolumeSource":{"description":"Represents a projected volume source","required":["sources"],"properties":{"defaultMode":{"description":"defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"sources":{"description":"sources is the list of volume projections","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeProjection"}}}},"v1.VolumeProjection":{"description":"Projection that may be projected along with other supported volume types","properties":{"configMap":{"description":"configMap information about the configMap data to project","$ref":"#/components/schemas/v1.ConfigMapProjection"},"downwardAPI":{"description":"downwardAPI information about the downwardAPI data to project","$ref":"#/components/schemas/v1.DownwardAPIProjection"},"secret":{"description":"secret information about the secret data to project","$ref":"#/components/schemas/v1.SecretProjection"},"serviceAccountToken":{"description":"serviceAccountToken is information about the serviceAccountToken data to project","$ref":"#/components/schemas/v1.ServiceAccountTokenProjection"}}},"v1.ConfigMapProjection":{"description":"Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.DownwardAPIProjection":{"description":"Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.","properties":{"items":{"description":"Items is a list of DownwardAPIVolume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.SecretProjection":{"description":"Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional field specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.ServiceAccountTokenProjection":{"description":"ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).","required":["path"],"properties":{"audience":{"description":"audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.","type":"string"},"expirationSeconds":{"description":"expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.","type":"integer","format":"int64"},"path":{"description":"path is the path relative to the mount point of the file to project the token into.","type":"string"}}},"v1.QuobyteVolumeSource":{"description":"Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.","required":["registry","volume"],"properties":{"group":{"description":"group to map volume access to Default is no group","type":"string"},"readOnly":{"description":"readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.","type":"boolean"},"registry":{"description":"registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes","type":"string"},"tenant":{"description":"tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin","type":"string"},"user":{"description":"user to map volume access to Defaults to serivceaccount user","type":"string"},"volume":{"description":"volume is a string that references an already created Quobyte volume by name.","type":"string"}}},"v1.RBDVolumeSource":{"description":"Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.","required":["monitors","image"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd","type":"string"},"image":{"description":"image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"keyring":{"description":"keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"monitors":{"description":"monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"pool":{"description":"pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"boolean"},"secretRef":{"description":"secretRef is name of the authentication secret for RBDUser. If provided overrides keyring. Default is nil. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"}}},"v1.ScaleIOVolumeSource":{"description":"ScaleIOVolumeSource represents a persistent ScaleIO volume","required":["gateway","system","secretRef"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\".","type":"string"},"gateway":{"description":"gateway is the host address of the ScaleIO API Gateway.","type":"string"},"protectionDomain":{"description":"protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef references to the secret for ScaleIO user and other sensitive information. If this is not provided, Login operation will fail.","$ref":"#/components/schemas/v1.LocalObjectReference"},"sslEnabled":{"description":"sslEnabled Flag enable/disable SSL communication with Gateway, default false","type":"boolean"},"storageMode":{"description":"storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.","type":"string"},"storagePool":{"description":"storagePool is the ScaleIO Storage Pool associated with the protection domain.","type":"string"},"system":{"description":"system is the name of the storage system as configured in ScaleIO.","type":"string"},"volumeName":{"description":"volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.","type":"string"}}},"v1.SecretVolumeSource":{"description":"Adapts a Secret into a volume.\n\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"optional":{"description":"optional field specify whether the Secret or its keys must be defined","type":"boolean"},"secretName":{"description":"secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","type":"string"}}},"v1.StorageOSVolumeSource":{"description":"Represents a StorageOS persistent volume resource.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeName":{"description":"volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.","type":"string"},"volumeNamespace":{"description":"volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.","type":"string"}}},"v1.VsphereVirtualDiskVolumeSource":{"description":"Represents a vSphere volume resource.","required":["volumePath"],"properties":{"fsType":{"description":"fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"storagePolicyID":{"description":"storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.","type":"string"},"storagePolicyName":{"description":"storagePolicyName is the storage Policy Based Management (SPBM) profile name.","type":"string"},"volumePath":{"description":"volumePath is the path that identifies vSphere volume vmdk","type":"string"}}},"v1alpha1.TTLStrategy":{"properties":{"secondsAfterCompletion":{"type":"integer","format":"int32"},"secondsAfterFailure":{"type":"integer","format":"int32"},"secondsAfterSuccess":{"type":"integer","format":"int32"}}},"v1alpha1.VolumeClaimGC":{"properties":{"strategy":{"type":"string"}}},"v1.PersistentVolumeClaim":{"description":"PersistentVolumeClaim is a user's request for and claim to a persistent volume","properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"description":"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"spec defines the desired characteristics of a volume requested by a pod author. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"},"status":{"description":"status represents the current information/status of a persistent volume claim. Read-only. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimStatus"}}},"v1.PersistentVolumeClaimStatus":{"description":"PersistentVolumeClaimStatus is the current status of a persistent volume claim.","properties":{"accessModes":{"description":"accessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"allocatedResources":{"description":"allocatedResources is the storage resource within AllocatedResources tracks the capacity allocated to a PVC. It may be larger than the actual capacity when a volume expansion operation is requested. For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. If a volume expansion capacity request is lowered, allocatedResources is only lowered if there are no expansion operations in progress and if the actual volume capacity is equal or lower than the requested capacity. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"capacity":{"description":"capacity represents the actual resources of the underlying volume.","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"conditions":{"description":"conditions is the current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'ResizeStarted'.","type":"array","items":{"$ref":"#/components/schemas/v1.PersistentVolumeClaimCondition"}},"phase":{"description":"phase represents the current phase of PersistentVolumeClaim.","type":"string"},"resizeStatus":{"description":"resizeStatus stores status of resize operation. ResizeStatus is not set by default but when expansion is complete resizeStatus is set to empty string by resize controller or kubelet. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.","type":"string"}}},"v1.PersistentVolumeClaimCondition":{"description":"PersistentVolumeClaimCondition contails details about state of pvc","required":["type","status"],"properties":{"lastProbeTime":{"description":"lastProbeTime is the time we probed the condition.","$ref":"#/components/schemas/v1.Time"},"lastTransitionTime":{"description":"lastTransitionTime is the time the condition transitioned from one status to another.","$ref":"#/components/schemas/v1.Time"},"message":{"description":"message is the human-readable message indicating details about last transition.","type":"string"},"reason":{"description":"reason is a unique, this should be a short, machine understandable string that gives the reason for condition's last transition. If it reports \"ResizeStarted\" that means the underlying persistent volume is being resized.","type":"string"},"status":{"type":"string"},"type":{"type":"string"}}},"v1alpha1.WorkflowMetadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}},"labelsFrom":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LabelValueFrom"}}}},"v1alpha1.LabelValueFrom":{"required":["expression"],"properties":{"expression":{"type":"string"}}},"v1alpha1.WorkflowTemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"}}},"v1alpha1.WorkflowStatus":{"properties":{"artifactGCStatus":{"$ref":"#/components/schemas/v1alpha1.ArtGCStatus"},"artifactRepositoryRef":{"$ref":"#/components/schemas/v1alpha1.ArtifactRepositoryRefStatus"},"compressedNodes":{"type":"string"},"conditions":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Condition"}},"estimatedDuration":{"type":"integer","format":"int32"},"finishedAt":{"$ref":"#/components/schemas/v1.Time"},"message":{"type":"string"},"nodes":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.NodeStatus"}},"offloadNodeStatusVersion":{"type":"string"},"outputs":{"$ref":"#/components/schemas/v1alpha1.Outputs"},"persistentVolumeClaims":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}},"phase":{"type":"string"},"progress":{"type":"string"},"resourcesDuration":{"type":"object","additionalProperties":{"type":"integer"}},"startedAt":{"$ref":"#/components/schemas/v1.Time"},"storedTemplates":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.Template"}},"storedWorkflowTemplateSpec":{"$ref":"#/components/schemas/v1alpha1.WorkflowSpec"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.SynchronizationStatus"},"taskResultsCompletionStatus":{"type":"object","additionalProperties":{"type":"boolean"}}}},"v1alpha1.ArtGCStatus":{"properties":{"notSpecified":{"type":"boolean"},"podsRecouped":{"type":"object","additionalProperties":{"type":"boolean"}},"strategiesProcessed":{"type":"object","additionalProperties":{"type":"boolean"}}}},"v1alpha1.ArtifactRepositoryRefStatus":{"properties":{"artifactRepository":{"$ref":"#/components/schemas/v1alpha1.ArtifactRepository"},"configMap":{"type":"string"},"default":{"type":"boolean"},"key":{"type":"string"},"namespace":{"type":"string"}}},"v1alpha1.ArtifactRepository":{"properties":{"archiveLogs":{"type":"boolean"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifactRepository"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifactRepository"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifactRepository"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifactRepository"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifactRepository"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3ArtifactRepository"}}},"v1alpha1.ArtifactoryArtifactRepository":{"properties":{"keyFormat":{"type":"string"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repoURL":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.AzureArtifactRepository":{"required":["endpoint","container"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blobNameFormat":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifactRepository":{"properties":{"bucket":{"type":"string"},"keyFormat":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifactRepository":{"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"pathFormat":{"type":"string"}}},"v1alpha1.OSSArtifactRepository":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"keyFormat":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.S3ArtifactRepository":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"keyFormat":{"type":"string"},"keyPrefix":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.Condition":{"properties":{"message":{"type":"string"},"status":{"type":"string"},"type":{"type":"string"}}},"v1alpha1.NodeStatus":{"required":["id","name","type"],"properties":{"boundaryID":{"type":"string"},"children":{"type":"array","items":{"type":"string"}},"daemoned":{"type":"boolean"},"displayName":{"type":"string"},"estimatedDuration":{"type":"integer","format":"int32"},"finishedAt":{"$ref":"#/components/schemas/v1.Time"},"hostNodeName":{"type":"string"},"id":{"type":"string"},"inputs":{"$ref":"#/components/schemas/v1alpha1.Inputs"},"memoizationStatus":{"$ref":"#/components/schemas/v1alpha1.MemoizationStatus"},"message":{"type":"string"},"name":{"type":"string"},"nodeFlag":{"$ref":"#/components/schemas/v1alpha1.NodeFlag"},"outboundNodes":{"type":"array","items":{"type":"string"}},"outputs":{"$ref":"#/components/schemas/v1alpha1.Outputs"},"phase":{"type":"string"},"podIP":{"type":"string"},"progress":{"type":"string"},"resourcesDuration":{"type":"object","additionalProperties":{"type":"integer"}},"startedAt":{"$ref":"#/components/schemas/v1.Time"},"synchronizationStatus":{"$ref":"#/components/schemas/v1alpha1.NodeSynchronizationStatus"},"templateName":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"},"templateScope":{"type":"string"},"type":{"type":"string"}}},"v1alpha1.MemoizationStatus":{"required":["hit","key","cacheName"],"properties":{"cacheName":{"type":"string"},"hit":{"type":"boolean"},"key":{"type":"string"}}},"v1alpha1.NodeFlag":{"properties":{"hooked":{"type":"boolean"},"retried":{"type":"boolean"}}},"v1alpha1.NodeSynchronizationStatus":{"properties":{"waiting":{"type":"string"}}},"v1alpha1.SynchronizationStatus":{"properties":{"mutex":{"$ref":"#/components/schemas/v1alpha1.MutexStatus"},"semaphore":{"$ref":"#/components/schemas/v1alpha1.SemaphoreStatus"}}},"v1alpha1.MutexStatus":{"properties":{"holding":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MutexHolding"}},"waiting":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MutexHolding"}}}},"v1alpha1.MutexHolding":{"properties":{"holder":{"type":"string"},"mutex":{"type":"string"}}},"v1alpha1.SemaphoreStatus":{"properties":{"holding":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.SemaphoreHolding"}},"waiting":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.SemaphoreHolding"}}}},"v1alpha1.SemaphoreHolding":{"properties":{"holders":{"type":"array","items":{"type":"string"}},"semaphore":{"type":"string"}}}}}} ``` ### Running a CronWorkflow ## POST /api/users/v1/clusters/{cluster-uuid}/cron-workflows > ```json {"openapi":"3.1.1","paths":{"/api/users/v1/clusters/{cluster-uuid}/cron-workflows":{"post":{"operationId":"CreateWorkflow","responses":{"200":{"description":"OK"}},"requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/v1alpha1.CronWorkflow"}}},"required":true}}}},"components":{"schemas":{"v1alpha1.CronWorkflow":{"required":["metadata","spec"],"properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"$ref":"#/components/schemas/v1alpha1.CronWorkflowSpec"},"status":{"$ref":"#/components/schemas/v1alpha1.CronWorkflowStatus"}}},"v1.ObjectMeta":{"description":"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.","properties":{"annotations":{"description":"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations","type":"object","additionalProperties":{"type":"string"}},"clusterName":{"description":"Deprecated: ClusterName is a legacy field that was always cleared by the system and never used; it will be removed completely in 1.25.\n\nThe name in the go struct is changed to help clients detect accidental use.","type":"string"},"creationTimestamp":{"description":"CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"deletionGracePeriodSeconds":{"description":"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.","type":"integer","format":"int64"},"deletionTimestamp":{"description":"DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"finalizers":{"description":"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.","type":"array","items":{"type":"string"}},"generateName":{"description":"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency","type":"string"},"generation":{"description":"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.","type":"integer","format":"int64"},"labels":{"description":"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels","type":"object","additionalProperties":{"type":"string"}},"managedFields":{"description":"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.","type":"array","items":{"$ref":"#/components/schemas/v1.ManagedFieldsEntry"}},"name":{"description":"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"namespace":{"description":"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces","type":"string"},"ownerReferences":{"description":"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.","type":"array","items":{"$ref":"#/components/schemas/v1.OwnerReference"}},"resourceVersion":{"description":"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency","type":"string"},"selfLink":{"description":"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.","type":"string"},"uid":{"description":"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}},"v1.ManagedFieldsEntry":{"description":"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.","properties":{"apiVersion":{"description":"APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.","type":"string"},"fieldsType":{"description":"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"","type":"string"},"fieldsV1":{"description":"FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type.","$ref":"#/components/schemas/v1.FieldsV1"},"manager":{"description":"Manager is an identifier of the workflow managing these fields.","type":"string"},"operation":{"description":"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.","type":"string"},"subresource":{"description":"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.","type":"string"},"time":{"description":"Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over.","$ref":"#/components/schemas/v1.Time"}}},"v1.FieldsV1":{"description":"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff"},"v1.OwnerReference":{"description":"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.","required":["apiVersion","kind","name","uid"],"properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"blockOwnerDeletion":{"description":"If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.","type":"boolean"},"controller":{"description":"If true, this reference points to the managing controller.","type":"boolean"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"uid":{"description":"UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1alpha1.CronWorkflowSpec":{"required":["workflowSpec","schedule"],"properties":{"concurrencyPolicy":{"type":"string"},"failedJobsHistoryLimit":{"type":"integer","format":"int32"},"schedule":{"type":"string"},"startingDeadlineSeconds":{"type":"integer","format":"int64"},"successfulJobsHistoryLimit":{"type":"integer","format":"int32"},"suspend":{"type":"boolean"},"timezone":{"type":"string"},"workflowMetadata":{"$ref":"#/components/schemas/v1.ObjectMeta"},"workflowSpec":{"$ref":"#/components/schemas/v1alpha1.WorkflowSpec"}}},"v1alpha1.WorkflowSpec":{"properties":{"activeDeadlineSeconds":{"type":"integer","format":"int64"},"affinity":{"$ref":"#/components/schemas/v1.Affinity"},"archiveLogs":{"type":"boolean"},"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.WorkflowLevelArtifactGC"},"artifactRepositoryRef":{"$ref":"#/components/schemas/v1alpha1.ArtifactRepositoryRef"},"automountServiceAccountToken":{"type":"boolean"},"dnsConfig":{"$ref":"#/components/schemas/v1.PodDNSConfig"},"dnsPolicy":{"type":"string"},"entrypoint":{"type":"string"},"executor":{"$ref":"#/components/schemas/v1alpha1.ExecutorConfig"},"hooks":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LifecycleHook"}},"hostAliases":{"type":"array","items":{"$ref":"#/components/schemas/v1.HostAlias"}},"hostNetwork":{"type":"boolean"},"imagePullSecrets":{"type":"array","items":{"$ref":"#/components/schemas/v1.LocalObjectReference"}},"metrics":{"$ref":"#/components/schemas/v1alpha1.Metrics"},"nodeSelector":{"type":"object","additionalProperties":{"type":"string"}},"onExit":{"type":"string"},"parallelism":{"type":"integer","format":"int64"},"podDisruptionBudget":{"$ref":"#/components/schemas/v1.PodDisruptionBudgetSpec"},"podGC":{"$ref":"#/components/schemas/v1alpha1.PodGC"},"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"podPriority":{"type":"integer","format":"int32"},"podPriorityClassName":{"type":"string"},"podSpecPatch":{"type":"string"},"priority":{"type":"integer","format":"int32"},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.RetryStrategy"},"schedulerName":{"type":"string"},"securityContext":{"$ref":"#/components/schemas/v1.PodSecurityContext"},"serviceAccountName":{"type":"string"},"shutdown":{"type":"string"},"suspend":{"type":"boolean"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.Synchronization"},"templateDefaults":{"$ref":"#/components/schemas/v1alpha1.Template"},"templates":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Template"}},"tolerations":{"type":"array","items":{"$ref":"#/components/schemas/v1.Toleration"}},"ttlStrategy":{"$ref":"#/components/schemas/v1alpha1.TTLStrategy"},"volumeClaimGC":{"$ref":"#/components/schemas/v1alpha1.VolumeClaimGC"},"volumeClaimTemplates":{"type":"array","items":{"$ref":"#/components/schemas/v1.PersistentVolumeClaim"}},"volumes":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}},"workflowMetadata":{"$ref":"#/components/schemas/v1alpha1.WorkflowMetadata"},"workflowTemplateRef":{"$ref":"#/components/schemas/v1alpha1.WorkflowTemplateRef"}}},"v1.Affinity":{"description":"Affinity is a group of affinity scheduling rules.","properties":{"nodeAffinity":{"description":"Describes node affinity scheduling rules for the pod.","$ref":"#/components/schemas/v1.NodeAffinity"},"podAffinity":{"description":"Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAffinity"},"podAntiAffinity":{"description":"Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAntiAffinity"}}},"v1.NodeAffinity":{"description":"Node affinity is a group of node affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.PreferredSchedulingTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.","$ref":"#/components/schemas/v1.NodeSelector"}}},"v1.PreferredSchedulingTerm":{"description":"An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).","required":["weight","preference"],"properties":{"preference":{"description":"A node selector term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.NodeSelectorTerm"},"weight":{"description":"Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.NodeSelectorTerm":{"description":"A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.","properties":{"matchExpressions":{"description":"A list of node selector requirements by node's labels.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}},"matchFields":{"description":"A list of node selector requirements by node's fields.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}}}},"v1.NodeSelectorRequirement":{"description":"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"The label key that the selector applies to.","type":"string"},"operator":{"description":"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.","type":"string"},"values":{"description":"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.NodeSelector":{"description":"A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.","required":["nodeSelectorTerms"],"properties":{"nodeSelectorTerms":{"description":"Required. A list of node selector terms. The terms are ORed.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorTerm"}}}},"v1.PodAffinity":{"description":"Pod affinity is a group of inter pod affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1.WeightedPodAffinityTerm":{"description":"The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)","required":["weight","podAffinityTerm"],"properties":{"podAffinityTerm":{"description":"Required. A pod affinity term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.PodAffinityTerm"},"weight":{"description":"weight associated with matching the corresponding podAffinityTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.PodAffinityTerm":{"description":"Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running","required":["topologyKey"],"properties":{"labelSelector":{"description":"A label query over a set of resources, in this case pods.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaceSelector":{"description":"A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means \"this pod's namespace\". An empty selector ({}) matches all namespaces.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaces":{"description":"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".","type":"array","items":{"type":"string"}},"topologyKey":{"description":"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.","type":"string"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.PodAntiAffinity":{"description":"Pod anti affinity is a group of inter pod anti affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1alpha1.Arguments":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Artifact":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.Parameter":{"required":["name"],"properties":{"default":{"type":"string"},"description":{"type":"string"},"enum":{"type":"array","items":{"type":"string"}},"globalName":{"type":"string"},"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.ValueFrom"}}},"v1alpha1.ValueFrom":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"default":{"type":"string"},"event":{"type":"string"},"expression":{"type":"string"},"jqFilter":{"type":"string"},"jsonPath":{"type":"string"},"parameter":{"type":"string"},"path":{"type":"string"},"supplied":{"$ref":"#/components/schemas/v1alpha1.SuppliedValueFrom"}}},"v1alpha1.SuppliedValueFrom":{},"v1alpha1.WorkflowLevelArtifactGC":{"properties":{"forceFinalizerRemoval":{"type":"boolean"},"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"podSpecPatch":{"type":"string"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.ArtifactRepositoryRef":{"properties":{"configMap":{"type":"string"},"key":{"type":"string"}}},"v1.PodDNSConfig":{"description":"PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy.","properties":{"nameservers":{"description":"A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed.","type":"array","items":{"type":"string"}},"options":{"description":"A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy.","type":"array","items":{"$ref":"#/components/schemas/v1.PodDNSConfigOption"}},"searches":{"description":"A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed.","type":"array","items":{"type":"string"}}}},"v1.PodDNSConfigOption":{"description":"PodDNSConfigOption defines DNS resolver options of a pod.","properties":{"name":{"description":"Required.","type":"string"},"value":{"type":"string"}}},"v1alpha1.ExecutorConfig":{"properties":{"serviceAccountName":{"type":"string"}}},"v1alpha1.LifecycleHook":{"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"expression":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"}}},"v1alpha1.TemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"},"template":{"type":"string"}}},"v1.HostAlias":{"description":"HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.","properties":{"hostnames":{"description":"Hostnames for the above IP address.","type":"array","items":{"type":"string"}},"ip":{"description":"IP address of the host file entry.","type":"string"}}},"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}},"v1alpha1.Metrics":{"required":["prometheus"],"properties":{"prometheus":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Prometheus"}}}},"v1alpha1.Prometheus":{"required":["name","help"],"properties":{"counter":{"$ref":"#/components/schemas/v1alpha1.Counter"},"gauge":{"$ref":"#/components/schemas/v1alpha1.Gauge"},"help":{"type":"string"},"histogram":{"$ref":"#/components/schemas/v1alpha1.Histogram"},"labels":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MetricLabel"}},"name":{"type":"string"},"when":{"type":"string"}}},"v1alpha1.Counter":{"required":["value"],"properties":{"value":{"type":"string"}}},"v1alpha1.Gauge":{"required":["value","realtime"],"properties":{"operation":{"type":"string"},"realtime":{"type":"boolean"},"value":{"type":"string"}}},"v1alpha1.Histogram":{"required":["value","buckets"],"properties":{"buckets":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Amount"}},"value":{"type":"string"}}},"v1alpha1.Amount":{},"v1alpha1.MetricLabel":{"required":["key","value"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1.PodDisruptionBudgetSpec":{"description":"PodDisruptionBudgetSpec is a description of a PodDisruptionBudget.","properties":{"maxUnavailable":{"description":"An eviction is allowed if at most \"maxUnavailable\" pods selected by \"selector\" are unavailable after the eviction, i.e. even in absence of the evicted pod. For example, one can prevent all voluntary evictions by specifying 0. This is a mutually exclusive setting with \"minAvailable\".","$ref":"#/components/schemas/intstr.IntOrString"},"minAvailable":{"description":"An eviction is allowed if at least \"minAvailable\" pods selected by \"selector\" will still be available after the eviction, i.e. even in the absence of the evicted pod. So for example you can prevent all voluntary evictions by specifying \"100%\".","$ref":"#/components/schemas/intstr.IntOrString"},"selector":{"description":"Label query over pods whose evictions are managed by the disruption budget. A null selector will match no pods, while an empty ({}) selector will select all pods within the namespace.","$ref":"#/components/schemas/v1.LabelSelector"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}},"v1alpha1.PodGC":{"properties":{"deleteDelayDuration":{"type":"string"},"labelSelector":{"$ref":"#/components/schemas/v1.LabelSelector"},"strategy":{"type":"string"}}},"v1alpha1.RetryStrategy":{"properties":{"affinity":{"$ref":"#/components/schemas/v1alpha1.RetryAffinity"},"backoff":{"$ref":"#/components/schemas/v1alpha1.Backoff"},"expression":{"type":"string"},"limit":{"$ref":"#/components/schemas/intstr.IntOrString"},"retryPolicy":{"type":"string"}}},"v1alpha1.RetryAffinity":{"properties":{"nodeAntiAffinity":{"$ref":"#/components/schemas/v1alpha1.RetryNodeAntiAffinity"}}},"v1alpha1.RetryNodeAntiAffinity":{},"v1alpha1.Backoff":{"properties":{"duration":{"type":"string"},"factor":{"$ref":"#/components/schemas/intstr.IntOrString"},"maxDuration":{"type":"string"}}},"v1.PodSecurityContext":{"description":"PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.","properties":{"fsGroup":{"description":"A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\n\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw ","type":"integer","format":"int64"},"fsGroupChangePolicy":{"description":"fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \"OnRootMismatch\" and \"Always\". If not specified, \"Always\" is used. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"supplementalGroups":{"description":"A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"type":"integer","format":"int64"}},"sysctls":{"description":"Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"$ref":"#/components/schemas/v1.Sysctl"}},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.SELinuxOptions":{"description":"SELinuxOptions are the labels to be applied to the container","properties":{"level":{"description":"Level is SELinux level label that applies to the container.","type":"string"},"role":{"description":"Role is a SELinux role label that applies to the container.","type":"string"},"type":{"description":"Type is a SELinux type label that applies to the container.","type":"string"},"user":{"description":"User is a SELinux user label that applies to the container.","type":"string"}}},"v1.SeccompProfile":{"description":"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.","required":["type"],"properties":{"localhostProfile":{"description":"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is \"Localhost\".","type":"string"},"type":{"description":"type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.","type":"string"}}},"v1.Sysctl":{"description":"Sysctl defines a kernel parameter to be set","required":["name","value"],"properties":{"name":{"description":"Name of a property to set","type":"string"},"value":{"description":"Value of a property to set","type":"string"}}},"v1.WindowsSecurityContextOptions":{"description":"WindowsSecurityContextOptions contain Windows-specific options and credentials.","properties":{"gmsaCredentialSpec":{"description":"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.","type":"string"},"gmsaCredentialSpecName":{"description":"GMSACredentialSpecName is the name of the GMSA credential spec to use.","type":"string"},"hostProcess":{"description":"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.","type":"boolean"},"runAsUserName":{"description":"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"string"}}},"v1alpha1.Synchronization":{"properties":{"mutex":{"$ref":"#/components/schemas/v1alpha1.Mutex"},"semaphore":{"$ref":"#/components/schemas/v1alpha1.SemaphoreRef"}}},"v1alpha1.Mutex":{"properties":{"name":{"type":"string"},"namespace":{"type":"string"}}},"v1alpha1.SemaphoreRef":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"namespace":{"type":"string"}}},"v1alpha1.Template":{"properties":{"activeDeadlineSeconds":{"$ref":"#/components/schemas/intstr.IntOrString"},"affinity":{"$ref":"#/components/schemas/v1.Affinity"},"archiveLocation":{"$ref":"#/components/schemas/v1alpha1.ArtifactLocation"},"automountServiceAccountToken":{"type":"boolean"},"container":{"$ref":"#/components/schemas/v1.Container"},"containerSet":{"$ref":"#/components/schemas/v1alpha1.ContainerSetTemplate"},"daemon":{"type":"boolean"},"dag":{"$ref":"#/components/schemas/v1alpha1.DAGTemplate"},"data":{"$ref":"#/components/schemas/v1alpha1.Data"},"executor":{"$ref":"#/components/schemas/v1alpha1.ExecutorConfig"},"failFast":{"type":"boolean"},"hostAliases":{"type":"array","items":{"$ref":"#/components/schemas/v1.HostAlias"}},"http":{"$ref":"#/components/schemas/v1alpha1.HTTP"},"initContainers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"inputs":{"$ref":"#/components/schemas/v1alpha1.Inputs"},"memoize":{"$ref":"#/components/schemas/v1alpha1.Memoize"},"metadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"metrics":{"$ref":"#/components/schemas/v1alpha1.Metrics"},"name":{"type":"string"},"nodeSelector":{"type":"object","additionalProperties":{"type":"string"}},"outputs":{"$ref":"#/components/schemas/v1alpha1.Outputs"},"parallelism":{"type":"integer","format":"int64"},"plugin":{"$ref":"#/components/schemas/v1alpha1.Plugin"},"podSpecPatch":{"type":"string"},"priority":{"type":"integer","format":"int32"},"priorityClassName":{"type":"string"},"resource":{"$ref":"#/components/schemas/v1alpha1.ResourceTemplate"},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.RetryStrategy"},"schedulerName":{"type":"string"},"script":{"$ref":"#/components/schemas/v1alpha1.ScriptTemplate"},"securityContext":{"$ref":"#/components/schemas/v1.PodSecurityContext"},"serviceAccountName":{"type":"string"},"sidecars":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"steps":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ParallelSteps"}},"suspend":{"$ref":"#/components/schemas/v1alpha1.SuspendTemplate"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.Synchronization"},"timeout":{"type":"string"},"tolerations":{"type":"array","items":{"$ref":"#/components/schemas/v1.Toleration"}},"volumes":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}}}},"v1alpha1.ArtifactLocation":{"properties":{"archiveLogs":{"type":"boolean"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"}}},"v1.Container":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1.EnvVar":{"description":"EnvVar represents an environment variable present in a Container.","required":["name"],"properties":{"name":{"description":"Name of the environment variable. Must be a C_IDENTIFIER.","type":"string"},"value":{"description":"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".","type":"string"},"valueFrom":{"description":"Source for the environment variable's value. Cannot be used if value is not empty.","$ref":"#/components/schemas/v1.EnvVarSource"}}},"v1.EnvVarSource":{"description":"EnvVarSource represents a source for the value of an EnvVar.","properties":{"configMapKeyRef":{"description":"Selects a key of a ConfigMap.","$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"fieldRef":{"description":"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"},"secretKeyRef":{"description":"Selects a key of a secret in the pod's namespace","$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.EnvFromSource":{"description":"EnvFromSource represents the source of a set of ConfigMaps","properties":{"configMapRef":{"description":"The ConfigMap to select from","$ref":"#/components/schemas/v1.ConfigMapEnvSource"},"prefix":{"description":"An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.","type":"string"},"secretRef":{"description":"The Secret to select from","$ref":"#/components/schemas/v1.SecretEnvSource"}}},"v1.ConfigMapEnvSource":{"description":"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap must be defined","type":"boolean"}}},"v1.SecretEnvSource":{"description":"SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret must be defined","type":"boolean"}}},"v1.Lifecycle":{"description":"Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.","properties":{"postStart":{"description":"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"},"preStop":{"description":"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"}}},"v1.LifecycleHandler":{"description":"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"tcpSocket":{"description":"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.","$ref":"#/components/schemas/v1.TCPSocketAction"}}},"v1.ExecAction":{"description":"ExecAction describes a \"run in container\" action.","properties":{"command":{"description":"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.","type":"array","items":{"type":"string"}}}},"v1.HTTPGetAction":{"description":"HTTPGetAction describes an action based on HTTP Get requests.","required":["port"],"properties":{"host":{"description":"Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.","type":"string"},"httpHeaders":{"description":"Custom headers to set in the request. HTTP allows repeated headers.","type":"array","items":{"$ref":"#/components/schemas/v1.HTTPHeader"}},"path":{"description":"Path to access on the HTTP server.","type":"string"},"port":{"description":"Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"},"scheme":{"description":"Scheme to use for connecting to the host. Defaults to HTTP.","type":"string"}}},"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}},"v1.TCPSocketAction":{"description":"TCPSocketAction describes an action based on opening a socket","required":["port"],"properties":{"host":{"description":"Optional: Host name to connect to, defaults to the pod IP.","type":"string"},"port":{"description":"Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"}}},"v1.Probe":{"description":"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"failureThreshold":{"description":"Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.","type":"integer","format":"int32"},"grpc":{"description":"GRPC specifies an action involving a GRPC port. This is a beta field and requires enabling GRPCContainerProbe feature gate.","$ref":"#/components/schemas/v1.GRPCAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"initialDelaySeconds":{"description":"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"},"periodSeconds":{"description":"How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.","type":"integer","format":"int32"},"successThreshold":{"description":"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.","type":"integer","format":"int32"},"tcpSocket":{"description":"TCPSocket specifies an action involving a TCP port.","$ref":"#/components/schemas/v1.TCPSocketAction"},"terminationGracePeriodSeconds":{"description":"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.","type":"integer","format":"int64"},"timeoutSeconds":{"description":"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"}}},"v1.GRPCAction":{"required":["port","service"],"properties":{"port":{"description":"Port number of the gRPC service. Number must be in the range 1 to 65535.","type":"integer","format":"int32"},"service":{"description":"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.","type":"string"}}},"v1.ContainerPort":{"description":"ContainerPort represents a network port in a single container.","required":["containerPort"],"properties":{"containerPort":{"description":"Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.","type":"integer","format":"int32"},"hostIP":{"description":"What host IP to bind the external port to.","type":"string"},"hostPort":{"description":"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.","type":"integer","format":"int32"},"name":{"description":"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.","type":"string"},"protocol":{"description":"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"v1.SecurityContext":{"description":"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.","properties":{"allowPrivilegeEscalation":{"description":"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"capabilities":{"description":"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.Capabilities"},"privileged":{"description":"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"procMount":{"description":"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"readOnlyRootFilesystem":{"description":"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Capabilities":{"description":"Adds and removes POSIX capabilities from running containers.","properties":{"add":{"description":"Added capabilities","type":"array","items":{"type":"string"}},"drop":{"description":"Removed capabilities","type":"array","items":{"type":"string"}}}},"v1.VolumeDevice":{"description":"volumeDevice describes a mapping of a raw block device within a container.","required":["name","devicePath"],"properties":{"devicePath":{"description":"devicePath is the path inside of the container that the device will be mapped to.","type":"string"},"name":{"description":"name must match the name of a persistentVolumeClaim in the pod","type":"string"}}},"v1.VolumeMount":{"description":"VolumeMount describes a mounting of a Volume within a container.","required":["name","mountPath"],"properties":{"mountPath":{"description":"Path within the container at which the volume should be mounted. Must not contain ':'.","type":"string"},"mountPropagation":{"description":"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10.","type":"string"},"name":{"description":"This must match the Name of a Volume.","type":"string"},"readOnly":{"description":"Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.","type":"boolean"},"subPath":{"description":"Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).","type":"string"},"subPathExpr":{"description":"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.","type":"string"}}},"v1alpha1.ContainerSetTemplate":{"required":["containers"],"properties":{"containers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ContainerNode"}},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.ContainerSetRetryStrategy"},"volumeMounts":{"type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}}}},"v1alpha1.ContainerNode":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"dependencies":{"type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.ContainerSetRetryStrategy":{"required":["retries"],"properties":{"duration":{"type":"string"},"retries":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"v1alpha1.DAGTemplate":{"required":["tasks"],"properties":{"failFast":{"type":"boolean"},"target":{"type":"string"},"tasks":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.DAGTask"}}}},"v1alpha1.DAGTask":{"required":["name"],"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"continueOn":{"$ref":"#/components/schemas/v1alpha1.ContinueOn"},"dependencies":{"type":"array","items":{"type":"string"}},"depends":{"type":"string"},"hooks":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LifecycleHook"}},"inline":{"$ref":"#/components/schemas/v1alpha1.Template"},"name":{"type":"string"},"onExit":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"},"when":{"type":"string"},"withItems":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Item"}},"withParam":{"type":"string"},"withSequence":{"$ref":"#/components/schemas/v1alpha1.Sequence"}}},"v1alpha1.ContinueOn":{"properties":{"error":{"type":"boolean"},"failed":{"type":"boolean"}}},"v1alpha1.Item":{},"v1alpha1.Sequence":{"properties":{"count":{"$ref":"#/components/schemas/intstr.IntOrString"},"end":{"$ref":"#/components/schemas/intstr.IntOrString"},"format":{"type":"string"},"start":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"v1alpha1.Data":{"required":["source","transformation"],"properties":{"source":{"$ref":"#/components/schemas/v1alpha1.DataSource"},"transformation":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.TransformationStep"}}}},"v1alpha1.DataSource":{"properties":{"artifactPaths":{"$ref":"#/components/schemas/v1alpha1.ArtifactPaths"}}},"v1alpha1.ArtifactPaths":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.TransformationStep":{"required":["expression"],"properties":{"expression":{"type":"string"}}},"v1alpha1.HTTP":{"required":["url"],"properties":{"body":{"type":"string"},"bodyFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPBodySource"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.HTTPHeader"}},"insecureSkipVerify":{"type":"boolean"},"method":{"type":"string"},"successCondition":{"type":"string"},"timeoutSeconds":{"type":"integer","format":"int64"},"url":{"type":"string"}}},"v1alpha1.HTTPBodySource":{"properties":{"bytes":{"type":"string"}}},"v1alpha1.HTTPHeader":{"required":["name"],"properties":{"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPHeaderSource"}}},"v1alpha1.HTTPHeaderSource":{"properties":{"secretKeyRef":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.UserContainer":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"mirrorVolumeMounts":{"type":"boolean"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.Inputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Memoize":{"required":["key","cache","maxAge"],"properties":{"cache":{"$ref":"#/components/schemas/v1alpha1.Cache"},"key":{"type":"string"},"maxAge":{"type":"string"}}},"v1alpha1.Cache":{"required":["configMap"],"properties":{"configMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"}}},"v1alpha1.Outputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"exitCode":{"type":"string"},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}},"result":{"type":"string"}}},"v1alpha1.Plugin":{},"v1alpha1.ResourceTemplate":{"required":["action"],"properties":{"action":{"type":"string"},"failureCondition":{"type":"string"},"flags":{"type":"array","items":{"type":"string"}},"manifest":{"type":"string"},"manifestFrom":{"$ref":"#/components/schemas/v1alpha1.ManifestFrom"},"mergeStrategy":{"type":"string"},"setOwnerReference":{"type":"boolean"},"successCondition":{"type":"string"}}},"v1alpha1.ManifestFrom":{"required":["artifact"],"properties":{"artifact":{"$ref":"#/components/schemas/v1alpha1.Artifact"}}},"v1alpha1.ScriptTemplate":{"description":"A single application container that you want to run within a pod.","required":["name","source"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"source":{"type":"string"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.ParallelSteps":{},"v1alpha1.SuspendTemplate":{"properties":{"duration":{"type":"string"}}},"v1.Toleration":{"description":"The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .","properties":{"effect":{"description":"Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.","type":"string"},"key":{"description":"Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.","type":"string"},"operator":{"description":"Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.","type":"string"},"tolerationSeconds":{"description":"TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.","type":"integer","format":"int64"},"value":{"description":"Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.","type":"string"}}},"v1.Volume":{"description":"Volume represents a named volume in a pod that may be accessed by any container in the pod.","required":["name"],"properties":{"awsElasticBlockStore":{"description":"awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","$ref":"#/components/schemas/v1.AWSElasticBlockStoreVolumeSource"},"azureDisk":{"description":"azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureDiskVolumeSource"},"azureFile":{"description":"azureFile represents an Azure File Service mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureFileVolumeSource"},"cephfs":{"description":"cephFS represents a Ceph FS mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.CephFSVolumeSource"},"cinder":{"description":"cinder represents a cinder volume attached and mounted on kubelets host machine. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","$ref":"#/components/schemas/v1.CinderVolumeSource"},"configMap":{"description":"configMap represents a configMap that should populate this volume","$ref":"#/components/schemas/v1.ConfigMapVolumeSource"},"csi":{"description":"csi (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers (Beta feature).","$ref":"#/components/schemas/v1.CSIVolumeSource"},"downwardAPI":{"description":"downwardAPI represents downward API about the pod that should populate this volume","$ref":"#/components/schemas/v1.DownwardAPIVolumeSource"},"emptyDir":{"description":"emptyDir represents a temporary directory that shares a pod's lifetime. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","$ref":"#/components/schemas/v1.EmptyDirVolumeSource"},"ephemeral":{"description":"ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed.\n\nUse this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity\n tracking are needed,\nc) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through\n a PersistentVolumeClaim (see EphemeralVolumeSource for more\n information on the connection between this volume type\n and PersistentVolumeClaim).\n\nUse PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod.\n\nUse CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information.\n\nA pod can use both types of ephemeral volumes and persistent volumes at the same time.","$ref":"#/components/schemas/v1.EphemeralVolumeSource"},"fc":{"description":"fc represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.","$ref":"#/components/schemas/v1.FCVolumeSource"},"flexVolume":{"description":"flexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","$ref":"#/components/schemas/v1.FlexVolumeSource"},"flocker":{"description":"flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running","$ref":"#/components/schemas/v1.FlockerVolumeSource"},"gcePersistentDisk":{"description":"gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","$ref":"#/components/schemas/v1.GCEPersistentDiskVolumeSource"},"gitRepo":{"description":"gitRepo represents a git repository at a particular revision. DEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","$ref":"#/components/schemas/v1.GitRepoVolumeSource"},"glusterfs":{"description":"glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/glusterfs/README.md","$ref":"#/components/schemas/v1.GlusterfsVolumeSource"},"hostPath":{"description":"hostPath represents a pre-existing file or directory on the host machine that is directly exposed to the container. This is generally used for system agents or other privileged things that are allowed to see the host machine. Most containers will NOT need this. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","$ref":"#/components/schemas/v1.HostPathVolumeSource"},"iscsi":{"description":"iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://examples.k8s.io/volumes/iscsi/README.md","$ref":"#/components/schemas/v1.ISCSIVolumeSource"},"name":{"description":"name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"nfs":{"description":"nfs represents an NFS mount on the host that shares a pod's lifetime More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","$ref":"#/components/schemas/v1.NFSVolumeSource"},"persistentVolumeClaim":{"description":"persistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimVolumeSource"},"photonPersistentDisk":{"description":"photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PhotonPersistentDiskVolumeSource"},"portworxVolume":{"description":"portworxVolume represents a portworx volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PortworxVolumeSource"},"projected":{"description":"projected items for all in one resources secrets, configmaps, and downward API","$ref":"#/components/schemas/v1.ProjectedVolumeSource"},"quobyte":{"description":"quobyte represents a Quobyte mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.QuobyteVolumeSource"},"rbd":{"description":"rbd represents a Rados Block Device mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/rbd/README.md","$ref":"#/components/schemas/v1.RBDVolumeSource"},"scaleIO":{"description":"scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.ScaleIOVolumeSource"},"secret":{"description":"secret represents a secret that should populate this volume. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","$ref":"#/components/schemas/v1.SecretVolumeSource"},"storageos":{"description":"storageOS represents a StorageOS volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.StorageOSVolumeSource"},"vsphereVolume":{"description":"vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.VsphereVirtualDiskVolumeSource"}}},"v1.AWSElasticBlockStoreVolumeSource":{"description":"Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).","type":"integer","format":"int32"},"readOnly":{"description":"readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"boolean"},"volumeID":{"description":"volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"}}},"v1.AzureDiskVolumeSource":{"description":"AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","required":["diskName","diskURI"],"properties":{"cachingMode":{"description":"cachingMode is the Host Caching mode: None, Read Only, Read Write.","type":"string"},"diskName":{"description":"diskName is the Name of the data disk in the blob storage","type":"string"},"diskURI":{"description":"diskURI is the URI of data disk in the blob storage","type":"string"},"fsType":{"description":"fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"kind":{"description":"kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"}}},"v1.AzureFileVolumeSource":{"description":"AzureFile represents an Azure File Service mount on the host and bind mount to the pod.","required":["secretName","shareName"],"properties":{"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretName":{"description":"secretName is the name of secret that contains Azure Storage Account Name and Key","type":"string"},"shareName":{"description":"shareName is the azure share Name","type":"string"}}},"v1.CephFSVolumeSource":{"description":"Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.","required":["monitors"],"properties":{"monitors":{"description":"monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"path":{"description":"path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /","type":"string"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"boolean"},"secretFile":{"description":"secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"},"secretRef":{"description":"secretRef is Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"}}},"v1.CinderVolumeSource":{"description":"Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"boolean"},"secretRef":{"description":"secretRef is optional: points to a secret object containing parameters used to connect to OpenStack.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeID":{"description":"volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"}}},"v1.ConfigMapVolumeSource":{"description":"Adapts a ConfigMap into a volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.KeyToPath":{"description":"Maps a string key to a path within a volume.","required":["key","path"],"properties":{"key":{"description":"key is the key to project.","type":"string"},"mode":{"description":"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.","type":"string"}}},"v1.CSIVolumeSource":{"description":"Represents a source location of a volume to mount, managed by an external CSI driver","required":["driver"],"properties":{"driver":{"description":"driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.","type":"string"},"fsType":{"description":"fsType to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.","type":"string"},"nodePublishSecretRef":{"description":"nodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secret references are passed.","$ref":"#/components/schemas/v1.LocalObjectReference"},"readOnly":{"description":"readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).","type":"boolean"},"volumeAttributes":{"description":"volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.","type":"object","additionalProperties":{"type":"string"}}}},"v1.DownwardAPIVolumeSource":{"description":"DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"Items is a list of downward API volume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.DownwardAPIVolumeFile":{"description":"DownwardAPIVolumeFile represents information to create the file containing the pod field","required":["path"],"properties":{"fieldRef":{"description":"Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"mode":{"description":"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'","type":"string"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"}}},"v1.EmptyDirVolumeSource":{"description":"Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.","properties":{"medium":{"description":"medium represents what type of storage medium should back this directory. The default is \"\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","type":"string"},"sizeLimit":{"description":"sizeLimit is the total amount of local storage required for this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. The default is nil which means that the limit is undefined. More info: http://kubernetes.io/docs/user-guide/volumes#emptydir","$ref":"#/components/schemas/resource.Quantity"}}},"v1.EphemeralVolumeSource":{"description":"Represents an ephemeral volume that is handled by a normal storage driver.","properties":{"volumeClaimTemplate":{"description":"Will be used to create a stand-alone PVC to provision the volume. The pod in which this EphemeralVolumeSource is embedded will be the owner of the PVC, i.e. the PVC will be deleted together with the pod. The name of the PVC will be `-` where `` is the name from the `PodSpec.Volumes` array entry. Pod validation will reject the pod if the concatenated name is not valid for a PVC (for example, too long).\n\nAn existing PVC with that name that is not owned by the pod will *not* be used for the pod to avoid using an unrelated volume by mistake. Starting the pod is then blocked until the unrelated PVC is removed. If such a pre-created PVC is meant to be used by the pod, the PVC has to updated with an owner reference to the pod once the pod exists. Normally this should not be necessary, but it may be useful when manually reconstructing a broken cluster.\n\nThis field is read-only and no changes will be made by Kubernetes to the PVC after it has been created.\n\nRequired, must not be nil.","$ref":"#/components/schemas/v1.PersistentVolumeClaimTemplate"}}},"v1.PersistentVolumeClaimTemplate":{"description":"PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.","required":["spec"],"properties":{"metadata":{"description":"May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"The specification for the PersistentVolumeClaim. The entire content is copied unchanged into the PVC that gets created from this template. The same fields as in a PersistentVolumeClaim are also valid here.","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"}}},"v1.PersistentVolumeClaimSpec":{"description":"PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes","properties":{"accessModes":{"description":"accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"dataSource":{"description":"dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"dataSourceRef":{"description":"dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"resources":{"description":"resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources","$ref":"#/components/schemas/v1.ResourceRequirements"},"selector":{"description":"selector is a label query over volumes to consider for binding.","$ref":"#/components/schemas/v1.LabelSelector"},"storageClassName":{"description":"storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1","type":"string"},"volumeMode":{"description":"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.","type":"string"},"volumeName":{"description":"volumeName is the binding reference to the PersistentVolume backing this claim.","type":"string"}}},"v1.TypedLocalObjectReference":{"description":"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.","required":["apiGroup","kind","name"],"properties":{"apiGroup":{"description":"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.","type":"string"},"kind":{"description":"Kind is the type of resource being referenced","type":"string"},"name":{"description":"Name is the name of resource being referenced","type":"string"}}},"v1.FCVolumeSource":{"description":"Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"lun":{"description":"lun is Optional: FC target lun number","type":"integer","format":"int32"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"targetWWNs":{"description":"targetWWNs is Optional: FC target worldwide names (WWNs)","type":"array","items":{"type":"string"}},"wwids":{"description":"wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.","type":"array","items":{"type":"string"}}}},"v1.FlexVolumeSource":{"description":"FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","required":["driver"],"properties":{"driver":{"description":"driver is the name of the driver to use for this volume.","type":"string"},"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.","type":"string"},"options":{"description":"options is Optional: this field holds extra command options if any.","type":"object","additionalProperties":{"type":"string"}},"readOnly":{"description":"readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef is Optional: secretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts.","$ref":"#/components/schemas/v1.LocalObjectReference"}}},"v1.FlockerVolumeSource":{"description":"Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.","properties":{"datasetName":{"description":"datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated","type":"string"},"datasetUUID":{"description":"datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset","type":"string"}}},"v1.GCEPersistentDiskVolumeSource":{"description":"Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.","required":["pdName"],"properties":{"fsType":{"description":"fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"integer","format":"int32"},"pdName":{"description":"pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"boolean"}}},"v1.GitRepoVolumeSource":{"description":"Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","required":["repository"],"properties":{"directory":{"description":"directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.","type":"string"},"repository":{"description":"repository is the URL","type":"string"},"revision":{"description":"revision is the commit hash for the specified revision.","type":"string"}}},"v1.GlusterfsVolumeSource":{"description":"Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.","required":["endpoints","path"],"properties":{"endpoints":{"description":"endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"path":{"description":"path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"readOnly":{"description":"readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"boolean"}}},"v1.HostPathVolumeSource":{"description":"Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.","required":["path"],"properties":{"path":{"description":"path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"},"type":{"description":"type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"}}},"v1.ISCSIVolumeSource":{"description":"Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.","required":["targetPortal","iqn","lun"],"properties":{"chapAuthDiscovery":{"description":"chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication","type":"boolean"},"chapAuthSession":{"description":"chapAuthSession defines whether support iSCSI Session CHAP authentication","type":"boolean"},"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi","type":"string"},"initiatorName":{"description":"initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.","type":"string"},"iqn":{"description":"iqn is the target iSCSI Qualified Name.","type":"string"},"iscsiInterface":{"description":"iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).","type":"string"},"lun":{"description":"lun represents iSCSI Target Lun number.","type":"integer","format":"int32"},"portals":{"description":"portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"array","items":{"type":"string"}},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.","type":"boolean"},"secretRef":{"description":"secretRef is the CHAP Secret for iSCSI target and initiator authentication","$ref":"#/components/schemas/v1.LocalObjectReference"},"targetPortal":{"description":"targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"string"}}},"v1.NFSVolumeSource":{"description":"Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.","required":["server","path"],"properties":{"path":{"description":"path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"},"readOnly":{"description":"readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"boolean"},"server":{"description":"server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"}}},"v1.PersistentVolumeClaimVolumeSource":{"description":"PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).","required":["claimName"],"properties":{"claimName":{"description":"claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","type":"string"},"readOnly":{"description":"readOnly Will force the ReadOnly setting in VolumeMounts. Default false.","type":"boolean"}}},"v1.PhotonPersistentDiskVolumeSource":{"description":"Represents a Photon Controller persistent disk resource.","required":["pdID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"pdID":{"description":"pdID is the ID that identifies Photon Controller persistent disk","type":"string"}}},"v1.PortworxVolumeSource":{"description":"PortworxVolumeSource represents a Portworx volume resource.","required":["volumeID"],"properties":{"fsType":{"description":"fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"volumeID":{"description":"volumeID uniquely identifies a Portworx volume","type":"string"}}},"v1.ProjectedVolumeSource":{"description":"Represents a projected volume source","required":["sources"],"properties":{"defaultMode":{"description":"defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"sources":{"description":"sources is the list of volume projections","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeProjection"}}}},"v1.VolumeProjection":{"description":"Projection that may be projected along with other supported volume types","properties":{"configMap":{"description":"configMap information about the configMap data to project","$ref":"#/components/schemas/v1.ConfigMapProjection"},"downwardAPI":{"description":"downwardAPI information about the downwardAPI data to project","$ref":"#/components/schemas/v1.DownwardAPIProjection"},"secret":{"description":"secret information about the secret data to project","$ref":"#/components/schemas/v1.SecretProjection"},"serviceAccountToken":{"description":"serviceAccountToken is information about the serviceAccountToken data to project","$ref":"#/components/schemas/v1.ServiceAccountTokenProjection"}}},"v1.ConfigMapProjection":{"description":"Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.DownwardAPIProjection":{"description":"Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.","properties":{"items":{"description":"Items is a list of DownwardAPIVolume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.SecretProjection":{"description":"Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional field specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.ServiceAccountTokenProjection":{"description":"ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).","required":["path"],"properties":{"audience":{"description":"audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.","type":"string"},"expirationSeconds":{"description":"expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.","type":"integer","format":"int64"},"path":{"description":"path is the path relative to the mount point of the file to project the token into.","type":"string"}}},"v1.QuobyteVolumeSource":{"description":"Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.","required":["registry","volume"],"properties":{"group":{"description":"group to map volume access to Default is no group","type":"string"},"readOnly":{"description":"readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.","type":"boolean"},"registry":{"description":"registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes","type":"string"},"tenant":{"description":"tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin","type":"string"},"user":{"description":"user to map volume access to Defaults to serivceaccount user","type":"string"},"volume":{"description":"volume is a string that references an already created Quobyte volume by name.","type":"string"}}},"v1.RBDVolumeSource":{"description":"Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.","required":["monitors","image"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd","type":"string"},"image":{"description":"image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"keyring":{"description":"keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"monitors":{"description":"monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"pool":{"description":"pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"boolean"},"secretRef":{"description":"secretRef is name of the authentication secret for RBDUser. If provided overrides keyring. Default is nil. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"}}},"v1.ScaleIOVolumeSource":{"description":"ScaleIOVolumeSource represents a persistent ScaleIO volume","required":["gateway","system","secretRef"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\".","type":"string"},"gateway":{"description":"gateway is the host address of the ScaleIO API Gateway.","type":"string"},"protectionDomain":{"description":"protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef references to the secret for ScaleIO user and other sensitive information. If this is not provided, Login operation will fail.","$ref":"#/components/schemas/v1.LocalObjectReference"},"sslEnabled":{"description":"sslEnabled Flag enable/disable SSL communication with Gateway, default false","type":"boolean"},"storageMode":{"description":"storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.","type":"string"},"storagePool":{"description":"storagePool is the ScaleIO Storage Pool associated with the protection domain.","type":"string"},"system":{"description":"system is the name of the storage system as configured in ScaleIO.","type":"string"},"volumeName":{"description":"volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.","type":"string"}}},"v1.SecretVolumeSource":{"description":"Adapts a Secret into a volume.\n\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"optional":{"description":"optional field specify whether the Secret or its keys must be defined","type":"boolean"},"secretName":{"description":"secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","type":"string"}}},"v1.StorageOSVolumeSource":{"description":"Represents a StorageOS persistent volume resource.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeName":{"description":"volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.","type":"string"},"volumeNamespace":{"description":"volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.","type":"string"}}},"v1.VsphereVirtualDiskVolumeSource":{"description":"Represents a vSphere volume resource.","required":["volumePath"],"properties":{"fsType":{"description":"fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"storagePolicyID":{"description":"storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.","type":"string"},"storagePolicyName":{"description":"storagePolicyName is the storage Policy Based Management (SPBM) profile name.","type":"string"},"volumePath":{"description":"volumePath is the path that identifies vSphere volume vmdk","type":"string"}}},"v1alpha1.TTLStrategy":{"properties":{"secondsAfterCompletion":{"type":"integer","format":"int32"},"secondsAfterFailure":{"type":"integer","format":"int32"},"secondsAfterSuccess":{"type":"integer","format":"int32"}}},"v1alpha1.VolumeClaimGC":{"properties":{"strategy":{"type":"string"}}},"v1.PersistentVolumeClaim":{"description":"PersistentVolumeClaim is a user's request for and claim to a persistent volume","properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"description":"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"spec defines the desired characteristics of a volume requested by a pod author. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"},"status":{"description":"status represents the current information/status of a persistent volume claim. Read-only. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimStatus"}}},"v1.PersistentVolumeClaimStatus":{"description":"PersistentVolumeClaimStatus is the current status of a persistent volume claim.","properties":{"accessModes":{"description":"accessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"allocatedResources":{"description":"allocatedResources is the storage resource within AllocatedResources tracks the capacity allocated to a PVC. It may be larger than the actual capacity when a volume expansion operation is requested. For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. If a volume expansion capacity request is lowered, allocatedResources is only lowered if there are no expansion operations in progress and if the actual volume capacity is equal or lower than the requested capacity. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"capacity":{"description":"capacity represents the actual resources of the underlying volume.","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"conditions":{"description":"conditions is the current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'ResizeStarted'.","type":"array","items":{"$ref":"#/components/schemas/v1.PersistentVolumeClaimCondition"}},"phase":{"description":"phase represents the current phase of PersistentVolumeClaim.","type":"string"},"resizeStatus":{"description":"resizeStatus stores status of resize operation. ResizeStatus is not set by default but when expansion is complete resizeStatus is set to empty string by resize controller or kubelet. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.","type":"string"}}},"v1.PersistentVolumeClaimCondition":{"description":"PersistentVolumeClaimCondition contails details about state of pvc","required":["type","status"],"properties":{"lastProbeTime":{"description":"lastProbeTime is the time we probed the condition.","$ref":"#/components/schemas/v1.Time"},"lastTransitionTime":{"description":"lastTransitionTime is the time the condition transitioned from one status to another.","$ref":"#/components/schemas/v1.Time"},"message":{"description":"message is the human-readable message indicating details about last transition.","type":"string"},"reason":{"description":"reason is a unique, this should be a short, machine understandable string that gives the reason for condition's last transition. If it reports \"ResizeStarted\" that means the underlying persistent volume is being resized.","type":"string"},"status":{"type":"string"},"type":{"type":"string"}}},"v1alpha1.WorkflowMetadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}},"labelsFrom":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LabelValueFrom"}}}},"v1alpha1.LabelValueFrom":{"required":["expression"],"properties":{"expression":{"type":"string"}}},"v1alpha1.WorkflowTemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"}}},"v1alpha1.CronWorkflowStatus":{"required":["active","lastScheduledTime","conditions"],"properties":{"active":{"type":"array","items":{"$ref":"#/components/schemas/v1.ObjectReference"}},"conditions":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Condition"}},"lastScheduledTime":{"$ref":"#/components/schemas/v1.Time"}}},"v1.ObjectReference":{"description":"ObjectReference contains enough information to let you inspect or modify the referred object.","properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"fieldPath":{"description":"If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \"spec.containers{name}\" (where \"name\" refers to the name of the container that triggered the event) or if no container name is specified \"spec.containers[2]\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.","type":"string"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"namespace":{"description":"Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/","type":"string"},"resourceVersion":{"description":"Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency","type":"string"},"uid":{"description":"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids","type":"string"}}},"v1alpha1.Condition":{"properties":{"message":{"type":"string"},"status":{"type":"string"},"type":{"type":"string"}}}}}} ``` ### List Workflow statuses on a Cluster ## GET /api/users/v1/clusters/{cluster-uuid}/runs > ```json {"openapi":"3.1.1","paths":{"/api/users/v1/clusters/{cluster-uuid}/runs":{"get":{"consumes":["application/json"],"operationId":"GetRuns","responses":{"200":{"description":"OK"}}}}}} ``` ## The big.Int object ```json {"openapi":"3.1.1","components":{"schemas":{"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}}}}} ``` ## The inf.Dec object ```json {"openapi":"3.1.1","components":{"schemas":{"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}}}}} ``` ## The intstr.IntOrString object ```json {"openapi":"3.1.1","components":{"schemas":{"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}}}}} ``` ## The model.Cluster object ```json {"openapi":"3.1.1","components":{"schemas":{"model.Cluster":{"required":["identityUUID","uuid","name","description","isActive","createdAt","updatedAt","isRegistered","orgUUID","pipekitAgentVersion","type"],"properties":{"apiKey":{"type":"string"},"createdAt":{"type":"string","format":"date-time"},"description":{"type":"string"},"identityUUID":{"type":"string"},"isActive":{"type":"boolean"},"isRegistered":{"type":"boolean"},"name":{"type":"string"},"orgUUID":{"type":"string"},"pipekitAgentVersion":{"type":"string"},"port":{"type":"integer","format":"int32"},"type":{"type":"array","items":{"type":"string"}},"updatedAt":{"type":"string","format":"date-time"},"uuid":{"type":"string"},"workflowGroupPriorities":{"type":"object","additionalProperties":{"type":"integer"}}}}}}} ``` ## The model.GitInfo object ```json {"openapi":"3.1.1","components":{"schemas":{"model.GitInfo":{"required":["gitRepoID","gitRepoName","gitOrg"],"properties":{"gitBranchName":{"type":"string"},"gitOrg":{"type":"string"},"gitRepoID":{"type":"string"},"gitRepoName":{"type":"string"},"gitRequestNumber":{"type":"string"},"gitSHA":{"type":"string"},"gitTag":{"type":"string"},"gitTargetBranch":{"type":"string"},"runUUID":{"type":"string"},"uuid":{"type":"string"}}}}}} ``` ## The model.Logs object ```json {"openapi":"3.1.1","components":{"schemas":{"model.Logs":{"required":["pipeUUID","runUUID","identityUUID","containerName","podName","logType","output","createdAt","updatedAt","streamCursor"],"properties":{"containerName":{"type":"string"},"createdAt":{"type":"string","format":"date-time"},"identityUUID":{"type":"string"},"logType":{"type":"string"},"nodeId":{"type":"string"},"output":{"type":"string"},"pipeUUID":{"type":"string"},"podName":{"type":"string"},"runUUID":{"type":"string"},"streamCursor":{"type":"string"},"updatedAt":{"type":"string","format":"date-time"}}}}}} ``` ## The model.Pipe object ```json {"openapi":"3.1.1","components":{"schemas":{"model.Pipe":{"required":["name","description","isActive","orgUUID","external"],"properties":{"UUID":{"type":"string"},"configFileLocation":{"type":"string"},"createdAt":{"type":"string"},"description":{"type":"string"},"external":{"type":"boolean"},"hasDeployKey":{"type":"boolean"},"identityUUID":{"type":"string"},"isActive":{"type":"boolean"},"kubeNamespace":{"type":"string"},"name":{"type":"string"},"orgUUID":{"type":"string"},"thirdPartyAccountUUID":{"type":"string"},"thirdPartyOwnerID":{"type":"string"},"thirdPartyOwnerName":{"type":"string"},"thirdPartyRepoID":{"type":"string"},"thirdPartyRepoName":{"type":"string"},"updatedAt":{"type":"string"}}}}}} ``` ## The model.PipeRun object ```json {"openapi":"3.1.1","components":{"schemas":{"model.PipeRun":{"properties":{"checkId":{"type":"integer","format":"int64"},"clusterName":{"type":"string"},"clusterUUID":{"type":"string"},"createdAt":{"type":"string","format":"date-time"},"gitInfo":{"$ref":"#/components/schemas/model.GitInfo"},"identityUUID":{"type":"string"},"message":{"type":"string"},"orgName":{"type":"string"},"orgUUID":{"type":"string"},"parentCronUUID":{"type":"string"},"pipeName":{"type":"string"},"pipeUUID":{"type":"string"},"progress":{"type":"string"},"runConditionUUID":{"type":"string"},"secretEnvUUID":{"type":"string"},"shaBranchOrTag":{"type":"string"},"sourceName":{"type":"string"},"sourceType":{"type":"string"},"status":{"type":"string"},"updatedAt":{"type":"string","format":"date-time"},"userName":{"type":"string"},"uuid":{"type":"string"}}},"model.GitInfo":{"required":["gitRepoID","gitRepoName","gitOrg"],"properties":{"gitBranchName":{"type":"string"},"gitOrg":{"type":"string"},"gitRepoID":{"type":"string"},"gitRepoName":{"type":"string"},"gitRequestNumber":{"type":"string"},"gitSHA":{"type":"string"},"gitTag":{"type":"string"},"gitTargetBranch":{"type":"string"},"runUUID":{"type":"string"},"uuid":{"type":"string"}}}}}} ``` ## The resource.Quantity object ```json {"openapi":"3.1.1","components":{"schemas":{"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}}}}} ``` ## The resource.infDecAmount object ```json {"openapi":"3.1.1","components":{"schemas":{"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}}}}} ``` ## The resource.int64Amount object ```json {"openapi":"3.1.1","components":{"schemas":{"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}}}}} ``` ## The v1.AWSElasticBlockStoreVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.AWSElasticBlockStoreVolumeSource":{"description":"Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).","type":"integer","format":"int32"},"readOnly":{"description":"readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"boolean"},"volumeID":{"description":"volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"}}}}}} ``` ## The v1.Affinity object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.Affinity":{"description":"Affinity is a group of affinity scheduling rules.","properties":{"nodeAffinity":{"description":"Describes node affinity scheduling rules for the pod.","$ref":"#/components/schemas/v1.NodeAffinity"},"podAffinity":{"description":"Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAffinity"},"podAntiAffinity":{"description":"Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAntiAffinity"}}},"v1.NodeAffinity":{"description":"Node affinity is a group of node affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.PreferredSchedulingTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.","$ref":"#/components/schemas/v1.NodeSelector"}}},"v1.PreferredSchedulingTerm":{"description":"An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).","required":["weight","preference"],"properties":{"preference":{"description":"A node selector term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.NodeSelectorTerm"},"weight":{"description":"Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.NodeSelectorTerm":{"description":"A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.","properties":{"matchExpressions":{"description":"A list of node selector requirements by node's labels.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}},"matchFields":{"description":"A list of node selector requirements by node's fields.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}}}},"v1.NodeSelectorRequirement":{"description":"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"The label key that the selector applies to.","type":"string"},"operator":{"description":"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.","type":"string"},"values":{"description":"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.NodeSelector":{"description":"A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.","required":["nodeSelectorTerms"],"properties":{"nodeSelectorTerms":{"description":"Required. A list of node selector terms. The terms are ORed.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorTerm"}}}},"v1.PodAffinity":{"description":"Pod affinity is a group of inter pod affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1.WeightedPodAffinityTerm":{"description":"The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)","required":["weight","podAffinityTerm"],"properties":{"podAffinityTerm":{"description":"Required. A pod affinity term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.PodAffinityTerm"},"weight":{"description":"weight associated with matching the corresponding podAffinityTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.PodAffinityTerm":{"description":"Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running","required":["topologyKey"],"properties":{"labelSelector":{"description":"A label query over a set of resources, in this case pods.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaceSelector":{"description":"A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means \"this pod's namespace\". An empty selector ({}) matches all namespaces.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaces":{"description":"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".","type":"array","items":{"type":"string"}},"topologyKey":{"description":"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.","type":"string"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.PodAntiAffinity":{"description":"Pod anti affinity is a group of inter pod anti affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}}}}} ``` ## The v1.AzureDiskVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.AzureDiskVolumeSource":{"description":"AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","required":["diskName","diskURI"],"properties":{"cachingMode":{"description":"cachingMode is the Host Caching mode: None, Read Only, Read Write.","type":"string"},"diskName":{"description":"diskName is the Name of the data disk in the blob storage","type":"string"},"diskURI":{"description":"diskURI is the URI of data disk in the blob storage","type":"string"},"fsType":{"description":"fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"kind":{"description":"kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"}}}}}} ``` ## The v1.AzureFileVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.AzureFileVolumeSource":{"description":"AzureFile represents an Azure File Service mount on the host and bind mount to the pod.","required":["secretName","shareName"],"properties":{"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretName":{"description":"secretName is the name of secret that contains Azure Storage Account Name and Key","type":"string"},"shareName":{"description":"shareName is the azure share Name","type":"string"}}}}}} ``` ## The v1.CSIVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.CSIVolumeSource":{"description":"Represents a source location of a volume to mount, managed by an external CSI driver","required":["driver"],"properties":{"driver":{"description":"driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.","type":"string"},"fsType":{"description":"fsType to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.","type":"string"},"nodePublishSecretRef":{"description":"nodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secret references are passed.","$ref":"#/components/schemas/v1.LocalObjectReference"},"readOnly":{"description":"readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).","type":"boolean"},"volumeAttributes":{"description":"volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}}}}} ``` ## The v1.Capabilities object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.Capabilities":{"description":"Adds and removes POSIX capabilities from running containers.","properties":{"add":{"description":"Added capabilities","type":"array","items":{"type":"string"}},"drop":{"description":"Removed capabilities","type":"array","items":{"type":"string"}}}}}}} ``` ## The v1.CephFSVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.CephFSVolumeSource":{"description":"Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.","required":["monitors"],"properties":{"monitors":{"description":"monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"path":{"description":"path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /","type":"string"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"boolean"},"secretFile":{"description":"secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"},"secretRef":{"description":"secretRef is Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"}}},"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}}}}} ``` ## The v1.CinderVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.CinderVolumeSource":{"description":"Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"boolean"},"secretRef":{"description":"secretRef is optional: points to a secret object containing parameters used to connect to OpenStack.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeID":{"description":"volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"}}},"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}}}}} ``` ## The v1.ConfigMapEnvSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.ConfigMapEnvSource":{"description":"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap must be defined","type":"boolean"}}}}}} ``` ## The v1.ConfigMapKeySelector object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}}}}} ``` ## The v1.ConfigMapProjection object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.ConfigMapProjection":{"description":"Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.KeyToPath":{"description":"Maps a string key to a path within a volume.","required":["key","path"],"properties":{"key":{"description":"key is the key to project.","type":"string"},"mode":{"description":"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.","type":"string"}}}}}} ``` ## The v1.ConfigMapVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.ConfigMapVolumeSource":{"description":"Adapts a ConfigMap into a volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.KeyToPath":{"description":"Maps a string key to a path within a volume.","required":["key","path"],"properties":{"key":{"description":"key is the key to project.","type":"string"},"mode":{"description":"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.","type":"string"}}}}}} ``` ## The v1.Container object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.Container":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1.EnvVar":{"description":"EnvVar represents an environment variable present in a Container.","required":["name"],"properties":{"name":{"description":"Name of the environment variable. Must be a C_IDENTIFIER.","type":"string"},"value":{"description":"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".","type":"string"},"valueFrom":{"description":"Source for the environment variable's value. Cannot be used if value is not empty.","$ref":"#/components/schemas/v1.EnvVarSource"}}},"v1.EnvVarSource":{"description":"EnvVarSource represents a source for the value of an EnvVar.","properties":{"configMapKeyRef":{"description":"Selects a key of a ConfigMap.","$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"fieldRef":{"description":"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"},"secretKeyRef":{"description":"Selects a key of a secret in the pod's namespace","$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.EnvFromSource":{"description":"EnvFromSource represents the source of a set of ConfigMaps","properties":{"configMapRef":{"description":"The ConfigMap to select from","$ref":"#/components/schemas/v1.ConfigMapEnvSource"},"prefix":{"description":"An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.","type":"string"},"secretRef":{"description":"The Secret to select from","$ref":"#/components/schemas/v1.SecretEnvSource"}}},"v1.ConfigMapEnvSource":{"description":"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap must be defined","type":"boolean"}}},"v1.SecretEnvSource":{"description":"SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret must be defined","type":"boolean"}}},"v1.Lifecycle":{"description":"Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.","properties":{"postStart":{"description":"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"},"preStop":{"description":"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"}}},"v1.LifecycleHandler":{"description":"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"tcpSocket":{"description":"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.","$ref":"#/components/schemas/v1.TCPSocketAction"}}},"v1.ExecAction":{"description":"ExecAction describes a \"run in container\" action.","properties":{"command":{"description":"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.","type":"array","items":{"type":"string"}}}},"v1.HTTPGetAction":{"description":"HTTPGetAction describes an action based on HTTP Get requests.","required":["port"],"properties":{"host":{"description":"Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.","type":"string"},"httpHeaders":{"description":"Custom headers to set in the request. HTTP allows repeated headers.","type":"array","items":{"$ref":"#/components/schemas/v1.HTTPHeader"}},"path":{"description":"Path to access on the HTTP server.","type":"string"},"port":{"description":"Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"},"scheme":{"description":"Scheme to use for connecting to the host. Defaults to HTTP.","type":"string"}}},"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}},"v1.TCPSocketAction":{"description":"TCPSocketAction describes an action based on opening a socket","required":["port"],"properties":{"host":{"description":"Optional: Host name to connect to, defaults to the pod IP.","type":"string"},"port":{"description":"Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"}}},"v1.Probe":{"description":"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"failureThreshold":{"description":"Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.","type":"integer","format":"int32"},"grpc":{"description":"GRPC specifies an action involving a GRPC port. This is a beta field and requires enabling GRPCContainerProbe feature gate.","$ref":"#/components/schemas/v1.GRPCAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"initialDelaySeconds":{"description":"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"},"periodSeconds":{"description":"How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.","type":"integer","format":"int32"},"successThreshold":{"description":"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.","type":"integer","format":"int32"},"tcpSocket":{"description":"TCPSocket specifies an action involving a TCP port.","$ref":"#/components/schemas/v1.TCPSocketAction"},"terminationGracePeriodSeconds":{"description":"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.","type":"integer","format":"int64"},"timeoutSeconds":{"description":"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"}}},"v1.GRPCAction":{"required":["port","service"],"properties":{"port":{"description":"Port number of the gRPC service. Number must be in the range 1 to 65535.","type":"integer","format":"int32"},"service":{"description":"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.","type":"string"}}},"v1.ContainerPort":{"description":"ContainerPort represents a network port in a single container.","required":["containerPort"],"properties":{"containerPort":{"description":"Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.","type":"integer","format":"int32"},"hostIP":{"description":"What host IP to bind the external port to.","type":"string"},"hostPort":{"description":"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.","type":"integer","format":"int32"},"name":{"description":"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.","type":"string"},"protocol":{"description":"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"v1.SecurityContext":{"description":"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.","properties":{"allowPrivilegeEscalation":{"description":"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"capabilities":{"description":"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.Capabilities"},"privileged":{"description":"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"procMount":{"description":"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"readOnlyRootFilesystem":{"description":"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Capabilities":{"description":"Adds and removes POSIX capabilities from running containers.","properties":{"add":{"description":"Added capabilities","type":"array","items":{"type":"string"}},"drop":{"description":"Removed capabilities","type":"array","items":{"type":"string"}}}},"v1.SELinuxOptions":{"description":"SELinuxOptions are the labels to be applied to the container","properties":{"level":{"description":"Level is SELinux level label that applies to the container.","type":"string"},"role":{"description":"Role is a SELinux role label that applies to the container.","type":"string"},"type":{"description":"Type is a SELinux type label that applies to the container.","type":"string"},"user":{"description":"User is a SELinux user label that applies to the container.","type":"string"}}},"v1.SeccompProfile":{"description":"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.","required":["type"],"properties":{"localhostProfile":{"description":"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is \"Localhost\".","type":"string"},"type":{"description":"type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.","type":"string"}}},"v1.WindowsSecurityContextOptions":{"description":"WindowsSecurityContextOptions contain Windows-specific options and credentials.","properties":{"gmsaCredentialSpec":{"description":"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.","type":"string"},"gmsaCredentialSpecName":{"description":"GMSACredentialSpecName is the name of the GMSA credential spec to use.","type":"string"},"hostProcess":{"description":"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.","type":"boolean"},"runAsUserName":{"description":"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"string"}}},"v1.VolumeDevice":{"description":"volumeDevice describes a mapping of a raw block device within a container.","required":["name","devicePath"],"properties":{"devicePath":{"description":"devicePath is the path inside of the container that the device will be mapped to.","type":"string"},"name":{"description":"name must match the name of a persistentVolumeClaim in the pod","type":"string"}}},"v1.VolumeMount":{"description":"VolumeMount describes a mounting of a Volume within a container.","required":["name","mountPath"],"properties":{"mountPath":{"description":"Path within the container at which the volume should be mounted. Must not contain ':'.","type":"string"},"mountPropagation":{"description":"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10.","type":"string"},"name":{"description":"This must match the Name of a Volume.","type":"string"},"readOnly":{"description":"Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.","type":"boolean"},"subPath":{"description":"Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).","type":"string"},"subPathExpr":{"description":"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.","type":"string"}}}}}} ``` ## The v1.ContainerPort object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.ContainerPort":{"description":"ContainerPort represents a network port in a single container.","required":["containerPort"],"properties":{"containerPort":{"description":"Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.","type":"integer","format":"int32"},"hostIP":{"description":"What host IP to bind the external port to.","type":"string"},"hostPort":{"description":"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.","type":"integer","format":"int32"},"name":{"description":"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.","type":"string"},"protocol":{"description":"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".","type":"string"}}}}}} ``` ## The v1.DownwardAPIProjection object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.DownwardAPIProjection":{"description":"Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.","properties":{"items":{"description":"Items is a list of DownwardAPIVolume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.DownwardAPIVolumeFile":{"description":"DownwardAPIVolumeFile represents information to create the file containing the pod field","required":["path"],"properties":{"fieldRef":{"description":"Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"mode":{"description":"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'","type":"string"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}}}}} ``` ## The v1.DownwardAPIVolumeFile object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.DownwardAPIVolumeFile":{"description":"DownwardAPIVolumeFile represents information to create the file containing the pod field","required":["path"],"properties":{"fieldRef":{"description":"Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"mode":{"description":"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'","type":"string"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}}}}} ``` ## The v1.DownwardAPIVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.DownwardAPIVolumeSource":{"description":"DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"Items is a list of downward API volume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.DownwardAPIVolumeFile":{"description":"DownwardAPIVolumeFile represents information to create the file containing the pod field","required":["path"],"properties":{"fieldRef":{"description":"Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"mode":{"description":"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'","type":"string"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}}}}} ``` ## The v1.EmptyDirVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.EmptyDirVolumeSource":{"description":"Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.","properties":{"medium":{"description":"medium represents what type of storage medium should back this directory. The default is \"\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","type":"string"},"sizeLimit":{"description":"sizeLimit is the total amount of local storage required for this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. The default is nil which means that the limit is undefined. More info: http://kubernetes.io/docs/user-guide/volumes#emptydir","$ref":"#/components/schemas/resource.Quantity"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}}}}} ``` ## The v1.EnvFromSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.EnvFromSource":{"description":"EnvFromSource represents the source of a set of ConfigMaps","properties":{"configMapRef":{"description":"The ConfigMap to select from","$ref":"#/components/schemas/v1.ConfigMapEnvSource"},"prefix":{"description":"An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.","type":"string"},"secretRef":{"description":"The Secret to select from","$ref":"#/components/schemas/v1.SecretEnvSource"}}},"v1.ConfigMapEnvSource":{"description":"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap must be defined","type":"boolean"}}},"v1.SecretEnvSource":{"description":"SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret must be defined","type":"boolean"}}}}}} ``` ## The v1.EnvVar object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.EnvVar":{"description":"EnvVar represents an environment variable present in a Container.","required":["name"],"properties":{"name":{"description":"Name of the environment variable. Must be a C_IDENTIFIER.","type":"string"},"value":{"description":"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".","type":"string"},"valueFrom":{"description":"Source for the environment variable's value. Cannot be used if value is not empty.","$ref":"#/components/schemas/v1.EnvVarSource"}}},"v1.EnvVarSource":{"description":"EnvVarSource represents a source for the value of an EnvVar.","properties":{"configMapKeyRef":{"description":"Selects a key of a ConfigMap.","$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"fieldRef":{"description":"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"},"secretKeyRef":{"description":"Selects a key of a secret in the pod's namespace","$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}}}}} ``` ## The v1.EnvVarSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.EnvVarSource":{"description":"EnvVarSource represents a source for the value of an EnvVar.","properties":{"configMapKeyRef":{"description":"Selects a key of a ConfigMap.","$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"fieldRef":{"description":"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"},"secretKeyRef":{"description":"Selects a key of a secret in the pod's namespace","$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}}}}} ``` ## The v1.EphemeralVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.EphemeralVolumeSource":{"description":"Represents an ephemeral volume that is handled by a normal storage driver.","properties":{"volumeClaimTemplate":{"description":"Will be used to create a stand-alone PVC to provision the volume. The pod in which this EphemeralVolumeSource is embedded will be the owner of the PVC, i.e. the PVC will be deleted together with the pod. The name of the PVC will be `-` where `` is the name from the `PodSpec.Volumes` array entry. Pod validation will reject the pod if the concatenated name is not valid for a PVC (for example, too long).\n\nAn existing PVC with that name that is not owned by the pod will *not* be used for the pod to avoid using an unrelated volume by mistake. Starting the pod is then blocked until the unrelated PVC is removed. If such a pre-created PVC is meant to be used by the pod, the PVC has to updated with an owner reference to the pod once the pod exists. Normally this should not be necessary, but it may be useful when manually reconstructing a broken cluster.\n\nThis field is read-only and no changes will be made by Kubernetes to the PVC after it has been created.\n\nRequired, must not be nil.","$ref":"#/components/schemas/v1.PersistentVolumeClaimTemplate"}}},"v1.PersistentVolumeClaimTemplate":{"description":"PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.","required":["spec"],"properties":{"metadata":{"description":"May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"The specification for the PersistentVolumeClaim. The entire content is copied unchanged into the PVC that gets created from this template. The same fields as in a PersistentVolumeClaim are also valid here.","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"}}},"v1.ObjectMeta":{"description":"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.","properties":{"annotations":{"description":"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations","type":"object","additionalProperties":{"type":"string"}},"clusterName":{"description":"Deprecated: ClusterName is a legacy field that was always cleared by the system and never used; it will be removed completely in 1.25.\n\nThe name in the go struct is changed to help clients detect accidental use.","type":"string"},"creationTimestamp":{"description":"CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"deletionGracePeriodSeconds":{"description":"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.","type":"integer","format":"int64"},"deletionTimestamp":{"description":"DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"finalizers":{"description":"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.","type":"array","items":{"type":"string"}},"generateName":{"description":"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency","type":"string"},"generation":{"description":"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.","type":"integer","format":"int64"},"labels":{"description":"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels","type":"object","additionalProperties":{"type":"string"}},"managedFields":{"description":"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.","type":"array","items":{"$ref":"#/components/schemas/v1.ManagedFieldsEntry"}},"name":{"description":"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"namespace":{"description":"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces","type":"string"},"ownerReferences":{"description":"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.","type":"array","items":{"$ref":"#/components/schemas/v1.OwnerReference"}},"resourceVersion":{"description":"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency","type":"string"},"selfLink":{"description":"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.","type":"string"},"uid":{"description":"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}},"v1.ManagedFieldsEntry":{"description":"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.","properties":{"apiVersion":{"description":"APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.","type":"string"},"fieldsType":{"description":"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"","type":"string"},"fieldsV1":{"description":"FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type.","$ref":"#/components/schemas/v1.FieldsV1"},"manager":{"description":"Manager is an identifier of the workflow managing these fields.","type":"string"},"operation":{"description":"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.","type":"string"},"subresource":{"description":"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.","type":"string"},"time":{"description":"Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over.","$ref":"#/components/schemas/v1.Time"}}},"v1.FieldsV1":{"description":"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff"},"v1.OwnerReference":{"description":"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.","required":["apiVersion","kind","name","uid"],"properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"blockOwnerDeletion":{"description":"If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.","type":"boolean"},"controller":{"description":"If true, this reference points to the managing controller.","type":"boolean"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"uid":{"description":"UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.PersistentVolumeClaimSpec":{"description":"PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes","properties":{"accessModes":{"description":"accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"dataSource":{"description":"dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"dataSourceRef":{"description":"dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"resources":{"description":"resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources","$ref":"#/components/schemas/v1.ResourceRequirements"},"selector":{"description":"selector is a label query over volumes to consider for binding.","$ref":"#/components/schemas/v1.LabelSelector"},"storageClassName":{"description":"storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1","type":"string"},"volumeMode":{"description":"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.","type":"string"},"volumeName":{"description":"volumeName is the binding reference to the PersistentVolume backing this claim.","type":"string"}}},"v1.TypedLocalObjectReference":{"description":"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.","required":["apiGroup","kind","name"],"properties":{"apiGroup":{"description":"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.","type":"string"},"kind":{"description":"Kind is the type of resource being referenced","type":"string"},"name":{"description":"Name is the name of resource being referenced","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}}}}} ``` ## The v1.ExecAction object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.ExecAction":{"description":"ExecAction describes a \"run in container\" action.","properties":{"command":{"description":"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.","type":"array","items":{"type":"string"}}}}}}} ``` ## The v1.FCVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.FCVolumeSource":{"description":"Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"lun":{"description":"lun is Optional: FC target lun number","type":"integer","format":"int32"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"targetWWNs":{"description":"targetWWNs is Optional: FC target worldwide names (WWNs)","type":"array","items":{"type":"string"}},"wwids":{"description":"wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.","type":"array","items":{"type":"string"}}}}}}} ``` ## The v1.FieldsV1 object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.FieldsV1":{"description":"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff"}}}} ``` ## The v1.FlexVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.FlexVolumeSource":{"description":"FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","required":["driver"],"properties":{"driver":{"description":"driver is the name of the driver to use for this volume.","type":"string"},"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.","type":"string"},"options":{"description":"options is Optional: this field holds extra command options if any.","type":"object","additionalProperties":{"type":"string"}},"readOnly":{"description":"readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef is Optional: secretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts.","$ref":"#/components/schemas/v1.LocalObjectReference"}}},"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}}}}} ``` ## The v1.FlockerVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.FlockerVolumeSource":{"description":"Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.","properties":{"datasetName":{"description":"datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated","type":"string"},"datasetUUID":{"description":"datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset","type":"string"}}}}}} ``` ## The v1.GCEPersistentDiskVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.GCEPersistentDiskVolumeSource":{"description":"Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.","required":["pdName"],"properties":{"fsType":{"description":"fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"integer","format":"int32"},"pdName":{"description":"pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"boolean"}}}}}} ``` ## The v1.GRPCAction object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.GRPCAction":{"required":["port","service"],"properties":{"port":{"description":"Port number of the gRPC service. Number must be in the range 1 to 65535.","type":"integer","format":"int32"},"service":{"description":"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.","type":"string"}}}}}} ``` ## The v1.GitRepoVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.GitRepoVolumeSource":{"description":"Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","required":["repository"],"properties":{"directory":{"description":"directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.","type":"string"},"repository":{"description":"repository is the URL","type":"string"},"revision":{"description":"revision is the commit hash for the specified revision.","type":"string"}}}}}} ``` ## The v1.GlusterfsVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.GlusterfsVolumeSource":{"description":"Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.","required":["endpoints","path"],"properties":{"endpoints":{"description":"endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"path":{"description":"path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"readOnly":{"description":"readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"boolean"}}}}}} ``` ## The v1.HTTPGetAction object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.HTTPGetAction":{"description":"HTTPGetAction describes an action based on HTTP Get requests.","required":["port"],"properties":{"host":{"description":"Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.","type":"string"},"httpHeaders":{"description":"Custom headers to set in the request. HTTP allows repeated headers.","type":"array","items":{"$ref":"#/components/schemas/v1.HTTPHeader"}},"path":{"description":"Path to access on the HTTP server.","type":"string"},"port":{"description":"Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"},"scheme":{"description":"Scheme to use for connecting to the host. Defaults to HTTP.","type":"string"}}},"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}}}}} ``` ## The v1.HTTPHeader object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}}}}} ``` ## The v1.HostAlias object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.HostAlias":{"description":"HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.","properties":{"hostnames":{"description":"Hostnames for the above IP address.","type":"array","items":{"type":"string"}},"ip":{"description":"IP address of the host file entry.","type":"string"}}}}}} ``` ## The v1.HostPathVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.HostPathVolumeSource":{"description":"Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.","required":["path"],"properties":{"path":{"description":"path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"},"type":{"description":"type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"}}}}}} ``` ## The v1.ISCSIVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.ISCSIVolumeSource":{"description":"Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.","required":["targetPortal","iqn","lun"],"properties":{"chapAuthDiscovery":{"description":"chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication","type":"boolean"},"chapAuthSession":{"description":"chapAuthSession defines whether support iSCSI Session CHAP authentication","type":"boolean"},"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi","type":"string"},"initiatorName":{"description":"initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.","type":"string"},"iqn":{"description":"iqn is the target iSCSI Qualified Name.","type":"string"},"iscsiInterface":{"description":"iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).","type":"string"},"lun":{"description":"lun represents iSCSI Target Lun number.","type":"integer","format":"int32"},"portals":{"description":"portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"array","items":{"type":"string"}},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.","type":"boolean"},"secretRef":{"description":"secretRef is the CHAP Secret for iSCSI target and initiator authentication","$ref":"#/components/schemas/v1.LocalObjectReference"},"targetPortal":{"description":"targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"string"}}},"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}}}}} ``` ## The v1.KeyToPath object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.KeyToPath":{"description":"Maps a string key to a path within a volume.","required":["key","path"],"properties":{"key":{"description":"key is the key to project.","type":"string"},"mode":{"description":"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.","type":"string"}}}}}} ``` ## The v1.LabelSelector object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}}}}} ``` ## The v1.LabelSelectorRequirement object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}}}}} ``` ## The v1.Lifecycle object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.Lifecycle":{"description":"Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.","properties":{"postStart":{"description":"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"},"preStop":{"description":"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"}}},"v1.LifecycleHandler":{"description":"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"tcpSocket":{"description":"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.","$ref":"#/components/schemas/v1.TCPSocketAction"}}},"v1.ExecAction":{"description":"ExecAction describes a \"run in container\" action.","properties":{"command":{"description":"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.","type":"array","items":{"type":"string"}}}},"v1.HTTPGetAction":{"description":"HTTPGetAction describes an action based on HTTP Get requests.","required":["port"],"properties":{"host":{"description":"Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.","type":"string"},"httpHeaders":{"description":"Custom headers to set in the request. HTTP allows repeated headers.","type":"array","items":{"$ref":"#/components/schemas/v1.HTTPHeader"}},"path":{"description":"Path to access on the HTTP server.","type":"string"},"port":{"description":"Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"},"scheme":{"description":"Scheme to use for connecting to the host. Defaults to HTTP.","type":"string"}}},"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}},"v1.TCPSocketAction":{"description":"TCPSocketAction describes an action based on opening a socket","required":["port"],"properties":{"host":{"description":"Optional: Host name to connect to, defaults to the pod IP.","type":"string"},"port":{"description":"Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"}}}}}} ``` ## The v1.LifecycleHandler object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.LifecycleHandler":{"description":"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"tcpSocket":{"description":"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.","$ref":"#/components/schemas/v1.TCPSocketAction"}}},"v1.ExecAction":{"description":"ExecAction describes a \"run in container\" action.","properties":{"command":{"description":"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.","type":"array","items":{"type":"string"}}}},"v1.HTTPGetAction":{"description":"HTTPGetAction describes an action based on HTTP Get requests.","required":["port"],"properties":{"host":{"description":"Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.","type":"string"},"httpHeaders":{"description":"Custom headers to set in the request. HTTP allows repeated headers.","type":"array","items":{"$ref":"#/components/schemas/v1.HTTPHeader"}},"path":{"description":"Path to access on the HTTP server.","type":"string"},"port":{"description":"Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"},"scheme":{"description":"Scheme to use for connecting to the host. Defaults to HTTP.","type":"string"}}},"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}},"v1.TCPSocketAction":{"description":"TCPSocketAction describes an action based on opening a socket","required":["port"],"properties":{"host":{"description":"Optional: Host name to connect to, defaults to the pod IP.","type":"string"},"port":{"description":"Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"}}}}}} ``` ## The v1.LocalObjectReference object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}}}}} ``` ## The v1.ManagedFieldsEntry object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.ManagedFieldsEntry":{"description":"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.","properties":{"apiVersion":{"description":"APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.","type":"string"},"fieldsType":{"description":"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"","type":"string"},"fieldsV1":{"description":"FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type.","$ref":"#/components/schemas/v1.FieldsV1"},"manager":{"description":"Manager is an identifier of the workflow managing these fields.","type":"string"},"operation":{"description":"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.","type":"string"},"subresource":{"description":"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.","type":"string"},"time":{"description":"Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over.","$ref":"#/components/schemas/v1.Time"}}},"v1.FieldsV1":{"description":"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff"},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}}}}} ``` ## The v1.NFSVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.NFSVolumeSource":{"description":"Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.","required":["server","path"],"properties":{"path":{"description":"path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"},"readOnly":{"description":"readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"boolean"},"server":{"description":"server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"}}}}}} ``` ## The v1.NodeAffinity object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.NodeAffinity":{"description":"Node affinity is a group of node affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.PreferredSchedulingTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.","$ref":"#/components/schemas/v1.NodeSelector"}}},"v1.PreferredSchedulingTerm":{"description":"An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).","required":["weight","preference"],"properties":{"preference":{"description":"A node selector term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.NodeSelectorTerm"},"weight":{"description":"Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.NodeSelectorTerm":{"description":"A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.","properties":{"matchExpressions":{"description":"A list of node selector requirements by node's labels.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}},"matchFields":{"description":"A list of node selector requirements by node's fields.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}}}},"v1.NodeSelectorRequirement":{"description":"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"The label key that the selector applies to.","type":"string"},"operator":{"description":"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.","type":"string"},"values":{"description":"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.NodeSelector":{"description":"A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.","required":["nodeSelectorTerms"],"properties":{"nodeSelectorTerms":{"description":"Required. A list of node selector terms. The terms are ORed.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorTerm"}}}}}}} ``` ## The v1.NodeSelector object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.NodeSelector":{"description":"A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.","required":["nodeSelectorTerms"],"properties":{"nodeSelectorTerms":{"description":"Required. A list of node selector terms. The terms are ORed.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorTerm"}}}},"v1.NodeSelectorTerm":{"description":"A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.","properties":{"matchExpressions":{"description":"A list of node selector requirements by node's labels.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}},"matchFields":{"description":"A list of node selector requirements by node's fields.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}}}},"v1.NodeSelectorRequirement":{"description":"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"The label key that the selector applies to.","type":"string"},"operator":{"description":"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.","type":"string"},"values":{"description":"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}}}}} ``` ## The v1.NodeSelectorRequirement object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.NodeSelectorRequirement":{"description":"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"The label key that the selector applies to.","type":"string"},"operator":{"description":"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.","type":"string"},"values":{"description":"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}}}}} ``` ## The v1.NodeSelectorTerm object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.NodeSelectorTerm":{"description":"A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.","properties":{"matchExpressions":{"description":"A list of node selector requirements by node's labels.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}},"matchFields":{"description":"A list of node selector requirements by node's fields.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}}}},"v1.NodeSelectorRequirement":{"description":"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"The label key that the selector applies to.","type":"string"},"operator":{"description":"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.","type":"string"},"values":{"description":"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}}}}} ``` ## The v1.ObjectFieldSelector object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}}}}} ``` ## The v1.ObjectMeta object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.ObjectMeta":{"description":"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.","properties":{"annotations":{"description":"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations","type":"object","additionalProperties":{"type":"string"}},"clusterName":{"description":"Deprecated: ClusterName is a legacy field that was always cleared by the system and never used; it will be removed completely in 1.25.\n\nThe name in the go struct is changed to help clients detect accidental use.","type":"string"},"creationTimestamp":{"description":"CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"deletionGracePeriodSeconds":{"description":"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.","type":"integer","format":"int64"},"deletionTimestamp":{"description":"DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"finalizers":{"description":"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.","type":"array","items":{"type":"string"}},"generateName":{"description":"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency","type":"string"},"generation":{"description":"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.","type":"integer","format":"int64"},"labels":{"description":"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels","type":"object","additionalProperties":{"type":"string"}},"managedFields":{"description":"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.","type":"array","items":{"$ref":"#/components/schemas/v1.ManagedFieldsEntry"}},"name":{"description":"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"namespace":{"description":"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces","type":"string"},"ownerReferences":{"description":"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.","type":"array","items":{"$ref":"#/components/schemas/v1.OwnerReference"}},"resourceVersion":{"description":"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency","type":"string"},"selfLink":{"description":"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.","type":"string"},"uid":{"description":"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}},"v1.ManagedFieldsEntry":{"description":"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.","properties":{"apiVersion":{"description":"APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.","type":"string"},"fieldsType":{"description":"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"","type":"string"},"fieldsV1":{"description":"FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type.","$ref":"#/components/schemas/v1.FieldsV1"},"manager":{"description":"Manager is an identifier of the workflow managing these fields.","type":"string"},"operation":{"description":"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.","type":"string"},"subresource":{"description":"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.","type":"string"},"time":{"description":"Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over.","$ref":"#/components/schemas/v1.Time"}}},"v1.FieldsV1":{"description":"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff"},"v1.OwnerReference":{"description":"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.","required":["apiVersion","kind","name","uid"],"properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"blockOwnerDeletion":{"description":"If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.","type":"boolean"},"controller":{"description":"If true, this reference points to the managing controller.","type":"boolean"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"uid":{"description":"UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}}}}} ``` ## The v1.ObjectReference object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.ObjectReference":{"description":"ObjectReference contains enough information to let you inspect or modify the referred object.","properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"fieldPath":{"description":"If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \"spec.containers{name}\" (where \"name\" refers to the name of the container that triggered the event) or if no container name is specified \"spec.containers[2]\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.","type":"string"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"namespace":{"description":"Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/","type":"string"},"resourceVersion":{"description":"Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency","type":"string"},"uid":{"description":"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids","type":"string"}}}}}} ``` ## The v1.OwnerReference object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.OwnerReference":{"description":"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.","required":["apiVersion","kind","name","uid"],"properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"blockOwnerDeletion":{"description":"If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.","type":"boolean"},"controller":{"description":"If true, this reference points to the managing controller.","type":"boolean"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"uid":{"description":"UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}}}}} ``` ## The v1.PersistentVolumeClaim object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.PersistentVolumeClaim":{"description":"PersistentVolumeClaim is a user's request for and claim to a persistent volume","properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"description":"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"spec defines the desired characteristics of a volume requested by a pod author. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"},"status":{"description":"status represents the current information/status of a persistent volume claim. Read-only. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimStatus"}}},"v1.ObjectMeta":{"description":"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.","properties":{"annotations":{"description":"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations","type":"object","additionalProperties":{"type":"string"}},"clusterName":{"description":"Deprecated: ClusterName is a legacy field that was always cleared by the system and never used; it will be removed completely in 1.25.\n\nThe name in the go struct is changed to help clients detect accidental use.","type":"string"},"creationTimestamp":{"description":"CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"deletionGracePeriodSeconds":{"description":"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.","type":"integer","format":"int64"},"deletionTimestamp":{"description":"DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"finalizers":{"description":"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.","type":"array","items":{"type":"string"}},"generateName":{"description":"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency","type":"string"},"generation":{"description":"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.","type":"integer","format":"int64"},"labels":{"description":"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels","type":"object","additionalProperties":{"type":"string"}},"managedFields":{"description":"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.","type":"array","items":{"$ref":"#/components/schemas/v1.ManagedFieldsEntry"}},"name":{"description":"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"namespace":{"description":"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces","type":"string"},"ownerReferences":{"description":"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.","type":"array","items":{"$ref":"#/components/schemas/v1.OwnerReference"}},"resourceVersion":{"description":"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency","type":"string"},"selfLink":{"description":"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.","type":"string"},"uid":{"description":"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}},"v1.ManagedFieldsEntry":{"description":"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.","properties":{"apiVersion":{"description":"APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.","type":"string"},"fieldsType":{"description":"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"","type":"string"},"fieldsV1":{"description":"FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type.","$ref":"#/components/schemas/v1.FieldsV1"},"manager":{"description":"Manager is an identifier of the workflow managing these fields.","type":"string"},"operation":{"description":"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.","type":"string"},"subresource":{"description":"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.","type":"string"},"time":{"description":"Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over.","$ref":"#/components/schemas/v1.Time"}}},"v1.FieldsV1":{"description":"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff"},"v1.OwnerReference":{"description":"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.","required":["apiVersion","kind","name","uid"],"properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"blockOwnerDeletion":{"description":"If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.","type":"boolean"},"controller":{"description":"If true, this reference points to the managing controller.","type":"boolean"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"uid":{"description":"UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.PersistentVolumeClaimSpec":{"description":"PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes","properties":{"accessModes":{"description":"accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"dataSource":{"description":"dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"dataSourceRef":{"description":"dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"resources":{"description":"resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources","$ref":"#/components/schemas/v1.ResourceRequirements"},"selector":{"description":"selector is a label query over volumes to consider for binding.","$ref":"#/components/schemas/v1.LabelSelector"},"storageClassName":{"description":"storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1","type":"string"},"volumeMode":{"description":"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.","type":"string"},"volumeName":{"description":"volumeName is the binding reference to the PersistentVolume backing this claim.","type":"string"}}},"v1.TypedLocalObjectReference":{"description":"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.","required":["apiGroup","kind","name"],"properties":{"apiGroup":{"description":"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.","type":"string"},"kind":{"description":"Kind is the type of resource being referenced","type":"string"},"name":{"description":"Name is the name of resource being referenced","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.PersistentVolumeClaimStatus":{"description":"PersistentVolumeClaimStatus is the current status of a persistent volume claim.","properties":{"accessModes":{"description":"accessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"allocatedResources":{"description":"allocatedResources is the storage resource within AllocatedResources tracks the capacity allocated to a PVC. It may be larger than the actual capacity when a volume expansion operation is requested. For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. If a volume expansion capacity request is lowered, allocatedResources is only lowered if there are no expansion operations in progress and if the actual volume capacity is equal or lower than the requested capacity. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"capacity":{"description":"capacity represents the actual resources of the underlying volume.","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"conditions":{"description":"conditions is the current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'ResizeStarted'.","type":"array","items":{"$ref":"#/components/schemas/v1.PersistentVolumeClaimCondition"}},"phase":{"description":"phase represents the current phase of PersistentVolumeClaim.","type":"string"},"resizeStatus":{"description":"resizeStatus stores status of resize operation. ResizeStatus is not set by default but when expansion is complete resizeStatus is set to empty string by resize controller or kubelet. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.","type":"string"}}},"v1.PersistentVolumeClaimCondition":{"description":"PersistentVolumeClaimCondition contails details about state of pvc","required":["type","status"],"properties":{"lastProbeTime":{"description":"lastProbeTime is the time we probed the condition.","$ref":"#/components/schemas/v1.Time"},"lastTransitionTime":{"description":"lastTransitionTime is the time the condition transitioned from one status to another.","$ref":"#/components/schemas/v1.Time"},"message":{"description":"message is the human-readable message indicating details about last transition.","type":"string"},"reason":{"description":"reason is a unique, this should be a short, machine understandable string that gives the reason for condition's last transition. If it reports \"ResizeStarted\" that means the underlying persistent volume is being resized.","type":"string"},"status":{"type":"string"},"type":{"type":"string"}}}}}} ``` ## The v1.PersistentVolumeClaimCondition object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.PersistentVolumeClaimCondition":{"description":"PersistentVolumeClaimCondition contails details about state of pvc","required":["type","status"],"properties":{"lastProbeTime":{"description":"lastProbeTime is the time we probed the condition.","$ref":"#/components/schemas/v1.Time"},"lastTransitionTime":{"description":"lastTransitionTime is the time the condition transitioned from one status to another.","$ref":"#/components/schemas/v1.Time"},"message":{"description":"message is the human-readable message indicating details about last transition.","type":"string"},"reason":{"description":"reason is a unique, this should be a short, machine understandable string that gives the reason for condition's last transition. If it reports \"ResizeStarted\" that means the underlying persistent volume is being resized.","type":"string"},"status":{"type":"string"},"type":{"type":"string"}}},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}}}}} ``` ## The v1.PersistentVolumeClaimSpec object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.PersistentVolumeClaimSpec":{"description":"PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes","properties":{"accessModes":{"description":"accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"dataSource":{"description":"dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"dataSourceRef":{"description":"dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"resources":{"description":"resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources","$ref":"#/components/schemas/v1.ResourceRequirements"},"selector":{"description":"selector is a label query over volumes to consider for binding.","$ref":"#/components/schemas/v1.LabelSelector"},"storageClassName":{"description":"storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1","type":"string"},"volumeMode":{"description":"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.","type":"string"},"volumeName":{"description":"volumeName is the binding reference to the PersistentVolume backing this claim.","type":"string"}}},"v1.TypedLocalObjectReference":{"description":"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.","required":["apiGroup","kind","name"],"properties":{"apiGroup":{"description":"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.","type":"string"},"kind":{"description":"Kind is the type of resource being referenced","type":"string"},"name":{"description":"Name is the name of resource being referenced","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}}}}} ``` ## The v1.PersistentVolumeClaimStatus object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.PersistentVolumeClaimStatus":{"description":"PersistentVolumeClaimStatus is the current status of a persistent volume claim.","properties":{"accessModes":{"description":"accessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"allocatedResources":{"description":"allocatedResources is the storage resource within AllocatedResources tracks the capacity allocated to a PVC. It may be larger than the actual capacity when a volume expansion operation is requested. For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. If a volume expansion capacity request is lowered, allocatedResources is only lowered if there are no expansion operations in progress and if the actual volume capacity is equal or lower than the requested capacity. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"capacity":{"description":"capacity represents the actual resources of the underlying volume.","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"conditions":{"description":"conditions is the current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'ResizeStarted'.","type":"array","items":{"$ref":"#/components/schemas/v1.PersistentVolumeClaimCondition"}},"phase":{"description":"phase represents the current phase of PersistentVolumeClaim.","type":"string"},"resizeStatus":{"description":"resizeStatus stores status of resize operation. ResizeStatus is not set by default but when expansion is complete resizeStatus is set to empty string by resize controller or kubelet. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.PersistentVolumeClaimCondition":{"description":"PersistentVolumeClaimCondition contails details about state of pvc","required":["type","status"],"properties":{"lastProbeTime":{"description":"lastProbeTime is the time we probed the condition.","$ref":"#/components/schemas/v1.Time"},"lastTransitionTime":{"description":"lastTransitionTime is the time the condition transitioned from one status to another.","$ref":"#/components/schemas/v1.Time"},"message":{"description":"message is the human-readable message indicating details about last transition.","type":"string"},"reason":{"description":"reason is a unique, this should be a short, machine understandable string that gives the reason for condition's last transition. If it reports \"ResizeStarted\" that means the underlying persistent volume is being resized.","type":"string"},"status":{"type":"string"},"type":{"type":"string"}}},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}}}}} ``` ## The v1.PersistentVolumeClaimTemplate object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.PersistentVolumeClaimTemplate":{"description":"PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.","required":["spec"],"properties":{"metadata":{"description":"May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"The specification for the PersistentVolumeClaim. The entire content is copied unchanged into the PVC that gets created from this template. The same fields as in a PersistentVolumeClaim are also valid here.","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"}}},"v1.ObjectMeta":{"description":"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.","properties":{"annotations":{"description":"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations","type":"object","additionalProperties":{"type":"string"}},"clusterName":{"description":"Deprecated: ClusterName is a legacy field that was always cleared by the system and never used; it will be removed completely in 1.25.\n\nThe name in the go struct is changed to help clients detect accidental use.","type":"string"},"creationTimestamp":{"description":"CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"deletionGracePeriodSeconds":{"description":"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.","type":"integer","format":"int64"},"deletionTimestamp":{"description":"DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"finalizers":{"description":"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.","type":"array","items":{"type":"string"}},"generateName":{"description":"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency","type":"string"},"generation":{"description":"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.","type":"integer","format":"int64"},"labels":{"description":"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels","type":"object","additionalProperties":{"type":"string"}},"managedFields":{"description":"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.","type":"array","items":{"$ref":"#/components/schemas/v1.ManagedFieldsEntry"}},"name":{"description":"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"namespace":{"description":"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces","type":"string"},"ownerReferences":{"description":"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.","type":"array","items":{"$ref":"#/components/schemas/v1.OwnerReference"}},"resourceVersion":{"description":"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency","type":"string"},"selfLink":{"description":"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.","type":"string"},"uid":{"description":"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}},"v1.ManagedFieldsEntry":{"description":"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.","properties":{"apiVersion":{"description":"APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.","type":"string"},"fieldsType":{"description":"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"","type":"string"},"fieldsV1":{"description":"FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type.","$ref":"#/components/schemas/v1.FieldsV1"},"manager":{"description":"Manager is an identifier of the workflow managing these fields.","type":"string"},"operation":{"description":"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.","type":"string"},"subresource":{"description":"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.","type":"string"},"time":{"description":"Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over.","$ref":"#/components/schemas/v1.Time"}}},"v1.FieldsV1":{"description":"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff"},"v1.OwnerReference":{"description":"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.","required":["apiVersion","kind","name","uid"],"properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"blockOwnerDeletion":{"description":"If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.","type":"boolean"},"controller":{"description":"If true, this reference points to the managing controller.","type":"boolean"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"uid":{"description":"UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.PersistentVolumeClaimSpec":{"description":"PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes","properties":{"accessModes":{"description":"accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"dataSource":{"description":"dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"dataSourceRef":{"description":"dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"resources":{"description":"resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources","$ref":"#/components/schemas/v1.ResourceRequirements"},"selector":{"description":"selector is a label query over volumes to consider for binding.","$ref":"#/components/schemas/v1.LabelSelector"},"storageClassName":{"description":"storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1","type":"string"},"volumeMode":{"description":"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.","type":"string"},"volumeName":{"description":"volumeName is the binding reference to the PersistentVolume backing this claim.","type":"string"}}},"v1.TypedLocalObjectReference":{"description":"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.","required":["apiGroup","kind","name"],"properties":{"apiGroup":{"description":"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.","type":"string"},"kind":{"description":"Kind is the type of resource being referenced","type":"string"},"name":{"description":"Name is the name of resource being referenced","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}}}}} ``` ## The v1.PersistentVolumeClaimVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.PersistentVolumeClaimVolumeSource":{"description":"PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).","required":["claimName"],"properties":{"claimName":{"description":"claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","type":"string"},"readOnly":{"description":"readOnly Will force the ReadOnly setting in VolumeMounts. Default false.","type":"boolean"}}}}}} ``` ## The v1.PhotonPersistentDiskVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.PhotonPersistentDiskVolumeSource":{"description":"Represents a Photon Controller persistent disk resource.","required":["pdID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"pdID":{"description":"pdID is the ID that identifies Photon Controller persistent disk","type":"string"}}}}}} ``` ## The v1.PodAffinity object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.PodAffinity":{"description":"Pod affinity is a group of inter pod affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1.WeightedPodAffinityTerm":{"description":"The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)","required":["weight","podAffinityTerm"],"properties":{"podAffinityTerm":{"description":"Required. A pod affinity term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.PodAffinityTerm"},"weight":{"description":"weight associated with matching the corresponding podAffinityTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.PodAffinityTerm":{"description":"Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running","required":["topologyKey"],"properties":{"labelSelector":{"description":"A label query over a set of resources, in this case pods.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaceSelector":{"description":"A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means \"this pod's namespace\". An empty selector ({}) matches all namespaces.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaces":{"description":"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".","type":"array","items":{"type":"string"}},"topologyKey":{"description":"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.","type":"string"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}}}}} ``` ## The v1.PodAffinityTerm object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.PodAffinityTerm":{"description":"Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running","required":["topologyKey"],"properties":{"labelSelector":{"description":"A label query over a set of resources, in this case pods.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaceSelector":{"description":"A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means \"this pod's namespace\". An empty selector ({}) matches all namespaces.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaces":{"description":"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".","type":"array","items":{"type":"string"}},"topologyKey":{"description":"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.","type":"string"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}}}}} ``` ## The v1.PodAntiAffinity object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.PodAntiAffinity":{"description":"Pod anti affinity is a group of inter pod anti affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1.WeightedPodAffinityTerm":{"description":"The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)","required":["weight","podAffinityTerm"],"properties":{"podAffinityTerm":{"description":"Required. A pod affinity term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.PodAffinityTerm"},"weight":{"description":"weight associated with matching the corresponding podAffinityTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.PodAffinityTerm":{"description":"Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running","required":["topologyKey"],"properties":{"labelSelector":{"description":"A label query over a set of resources, in this case pods.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaceSelector":{"description":"A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means \"this pod's namespace\". An empty selector ({}) matches all namespaces.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaces":{"description":"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".","type":"array","items":{"type":"string"}},"topologyKey":{"description":"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.","type":"string"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}}}}} ``` ## The v1.PodDNSConfig object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.PodDNSConfig":{"description":"PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy.","properties":{"nameservers":{"description":"A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed.","type":"array","items":{"type":"string"}},"options":{"description":"A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy.","type":"array","items":{"$ref":"#/components/schemas/v1.PodDNSConfigOption"}},"searches":{"description":"A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed.","type":"array","items":{"type":"string"}}}},"v1.PodDNSConfigOption":{"description":"PodDNSConfigOption defines DNS resolver options of a pod.","properties":{"name":{"description":"Required.","type":"string"},"value":{"type":"string"}}}}}} ``` ## The v1.PodDNSConfigOption object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.PodDNSConfigOption":{"description":"PodDNSConfigOption defines DNS resolver options of a pod.","properties":{"name":{"description":"Required.","type":"string"},"value":{"type":"string"}}}}}} ``` ## The v1.PodDisruptionBudgetSpec object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.PodDisruptionBudgetSpec":{"description":"PodDisruptionBudgetSpec is a description of a PodDisruptionBudget.","properties":{"maxUnavailable":{"description":"An eviction is allowed if at most \"maxUnavailable\" pods selected by \"selector\" are unavailable after the eviction, i.e. even in absence of the evicted pod. For example, one can prevent all voluntary evictions by specifying 0. This is a mutually exclusive setting with \"minAvailable\".","$ref":"#/components/schemas/intstr.IntOrString"},"minAvailable":{"description":"An eviction is allowed if at least \"minAvailable\" pods selected by \"selector\" will still be available after the eviction, i.e. even in the absence of the evicted pod. So for example you can prevent all voluntary evictions by specifying \"100%\".","$ref":"#/components/schemas/intstr.IntOrString"},"selector":{"description":"Label query over pods whose evictions are managed by the disruption budget. A null selector will match no pods, while an empty ({}) selector will select all pods within the namespace.","$ref":"#/components/schemas/v1.LabelSelector"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}}}}} ``` ## The v1.PodSecurityContext object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.PodSecurityContext":{"description":"PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.","properties":{"fsGroup":{"description":"A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\n\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw ","type":"integer","format":"int64"},"fsGroupChangePolicy":{"description":"fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \"OnRootMismatch\" and \"Always\". If not specified, \"Always\" is used. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"supplementalGroups":{"description":"A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"type":"integer","format":"int64"}},"sysctls":{"description":"Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"$ref":"#/components/schemas/v1.Sysctl"}},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.SELinuxOptions":{"description":"SELinuxOptions are the labels to be applied to the container","properties":{"level":{"description":"Level is SELinux level label that applies to the container.","type":"string"},"role":{"description":"Role is a SELinux role label that applies to the container.","type":"string"},"type":{"description":"Type is a SELinux type label that applies to the container.","type":"string"},"user":{"description":"User is a SELinux user label that applies to the container.","type":"string"}}},"v1.SeccompProfile":{"description":"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.","required":["type"],"properties":{"localhostProfile":{"description":"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is \"Localhost\".","type":"string"},"type":{"description":"type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.","type":"string"}}},"v1.Sysctl":{"description":"Sysctl defines a kernel parameter to be set","required":["name","value"],"properties":{"name":{"description":"Name of a property to set","type":"string"},"value":{"description":"Value of a property to set","type":"string"}}},"v1.WindowsSecurityContextOptions":{"description":"WindowsSecurityContextOptions contain Windows-specific options and credentials.","properties":{"gmsaCredentialSpec":{"description":"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.","type":"string"},"gmsaCredentialSpecName":{"description":"GMSACredentialSpecName is the name of the GMSA credential spec to use.","type":"string"},"hostProcess":{"description":"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.","type":"boolean"},"runAsUserName":{"description":"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"string"}}}}}} ``` ## The v1.PortworxVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.PortworxVolumeSource":{"description":"PortworxVolumeSource represents a Portworx volume resource.","required":["volumeID"],"properties":{"fsType":{"description":"fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"volumeID":{"description":"volumeID uniquely identifies a Portworx volume","type":"string"}}}}}} ``` ## The v1.PreferredSchedulingTerm object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.PreferredSchedulingTerm":{"description":"An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).","required":["weight","preference"],"properties":{"preference":{"description":"A node selector term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.NodeSelectorTerm"},"weight":{"description":"Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.NodeSelectorTerm":{"description":"A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.","properties":{"matchExpressions":{"description":"A list of node selector requirements by node's labels.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}},"matchFields":{"description":"A list of node selector requirements by node's fields.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}}}},"v1.NodeSelectorRequirement":{"description":"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"The label key that the selector applies to.","type":"string"},"operator":{"description":"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.","type":"string"},"values":{"description":"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}}}}} ``` ## The v1.Probe object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.Probe":{"description":"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"failureThreshold":{"description":"Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.","type":"integer","format":"int32"},"grpc":{"description":"GRPC specifies an action involving a GRPC port. This is a beta field and requires enabling GRPCContainerProbe feature gate.","$ref":"#/components/schemas/v1.GRPCAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"initialDelaySeconds":{"description":"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"},"periodSeconds":{"description":"How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.","type":"integer","format":"int32"},"successThreshold":{"description":"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.","type":"integer","format":"int32"},"tcpSocket":{"description":"TCPSocket specifies an action involving a TCP port.","$ref":"#/components/schemas/v1.TCPSocketAction"},"terminationGracePeriodSeconds":{"description":"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.","type":"integer","format":"int64"},"timeoutSeconds":{"description":"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"}}},"v1.ExecAction":{"description":"ExecAction describes a \"run in container\" action.","properties":{"command":{"description":"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.","type":"array","items":{"type":"string"}}}},"v1.GRPCAction":{"required":["port","service"],"properties":{"port":{"description":"Port number of the gRPC service. Number must be in the range 1 to 65535.","type":"integer","format":"int32"},"service":{"description":"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.","type":"string"}}},"v1.HTTPGetAction":{"description":"HTTPGetAction describes an action based on HTTP Get requests.","required":["port"],"properties":{"host":{"description":"Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.","type":"string"},"httpHeaders":{"description":"Custom headers to set in the request. HTTP allows repeated headers.","type":"array","items":{"$ref":"#/components/schemas/v1.HTTPHeader"}},"path":{"description":"Path to access on the HTTP server.","type":"string"},"port":{"description":"Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"},"scheme":{"description":"Scheme to use for connecting to the host. Defaults to HTTP.","type":"string"}}},"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}},"v1.TCPSocketAction":{"description":"TCPSocketAction describes an action based on opening a socket","required":["port"],"properties":{"host":{"description":"Optional: Host name to connect to, defaults to the pod IP.","type":"string"},"port":{"description":"Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"}}}}}} ``` ## The v1.ProjectedVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.ProjectedVolumeSource":{"description":"Represents a projected volume source","required":["sources"],"properties":{"defaultMode":{"description":"defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"sources":{"description":"sources is the list of volume projections","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeProjection"}}}},"v1.VolumeProjection":{"description":"Projection that may be projected along with other supported volume types","properties":{"configMap":{"description":"configMap information about the configMap data to project","$ref":"#/components/schemas/v1.ConfigMapProjection"},"downwardAPI":{"description":"downwardAPI information about the downwardAPI data to project","$ref":"#/components/schemas/v1.DownwardAPIProjection"},"secret":{"description":"secret information about the secret data to project","$ref":"#/components/schemas/v1.SecretProjection"},"serviceAccountToken":{"description":"serviceAccountToken is information about the serviceAccountToken data to project","$ref":"#/components/schemas/v1.ServiceAccountTokenProjection"}}},"v1.ConfigMapProjection":{"description":"Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.KeyToPath":{"description":"Maps a string key to a path within a volume.","required":["key","path"],"properties":{"key":{"description":"key is the key to project.","type":"string"},"mode":{"description":"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.","type":"string"}}},"v1.DownwardAPIProjection":{"description":"Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.","properties":{"items":{"description":"Items is a list of DownwardAPIVolume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.DownwardAPIVolumeFile":{"description":"DownwardAPIVolumeFile represents information to create the file containing the pod field","required":["path"],"properties":{"fieldRef":{"description":"Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"mode":{"description":"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'","type":"string"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.SecretProjection":{"description":"Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional field specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.ServiceAccountTokenProjection":{"description":"ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).","required":["path"],"properties":{"audience":{"description":"audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.","type":"string"},"expirationSeconds":{"description":"expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.","type":"integer","format":"int64"},"path":{"description":"path is the path relative to the mount point of the file to project the token into.","type":"string"}}}}}} ``` ## The v1.QuobyteVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.QuobyteVolumeSource":{"description":"Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.","required":["registry","volume"],"properties":{"group":{"description":"group to map volume access to Default is no group","type":"string"},"readOnly":{"description":"readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.","type":"boolean"},"registry":{"description":"registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes","type":"string"},"tenant":{"description":"tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin","type":"string"},"user":{"description":"user to map volume access to Defaults to serivceaccount user","type":"string"},"volume":{"description":"volume is a string that references an already created Quobyte volume by name.","type":"string"}}}}}} ``` ## The v1.RBDVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.RBDVolumeSource":{"description":"Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.","required":["monitors","image"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd","type":"string"},"image":{"description":"image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"keyring":{"description":"keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"monitors":{"description":"monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"pool":{"description":"pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"boolean"},"secretRef":{"description":"secretRef is name of the authentication secret for RBDUser. If provided overrides keyring. Default is nil. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"}}},"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}}}}} ``` ## The v1.ResourceFieldSelector object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}}}}} ``` ## The v1.ResourceRequirements object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}}}}} ``` ## The v1.SELinuxOptions object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.SELinuxOptions":{"description":"SELinuxOptions are the labels to be applied to the container","properties":{"level":{"description":"Level is SELinux level label that applies to the container.","type":"string"},"role":{"description":"Role is a SELinux role label that applies to the container.","type":"string"},"type":{"description":"Type is a SELinux type label that applies to the container.","type":"string"},"user":{"description":"User is a SELinux user label that applies to the container.","type":"string"}}}}}} ``` ## The v1.ScaleIOVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.ScaleIOVolumeSource":{"description":"ScaleIOVolumeSource represents a persistent ScaleIO volume","required":["gateway","system","secretRef"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\".","type":"string"},"gateway":{"description":"gateway is the host address of the ScaleIO API Gateway.","type":"string"},"protectionDomain":{"description":"protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef references to the secret for ScaleIO user and other sensitive information. If this is not provided, Login operation will fail.","$ref":"#/components/schemas/v1.LocalObjectReference"},"sslEnabled":{"description":"sslEnabled Flag enable/disable SSL communication with Gateway, default false","type":"boolean"},"storageMode":{"description":"storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.","type":"string"},"storagePool":{"description":"storagePool is the ScaleIO Storage Pool associated with the protection domain.","type":"string"},"system":{"description":"system is the name of the storage system as configured in ScaleIO.","type":"string"},"volumeName":{"description":"volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.","type":"string"}}},"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}}}}} ``` ## The v1.SeccompProfile object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.SeccompProfile":{"description":"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.","required":["type"],"properties":{"localhostProfile":{"description":"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is \"Localhost\".","type":"string"},"type":{"description":"type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.","type":"string"}}}}}} ``` ## The v1.SecretEnvSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.SecretEnvSource":{"description":"SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret must be defined","type":"boolean"}}}}}} ``` ## The v1.SecretKeySelector object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}}}}} ``` ## The v1.SecretProjection object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.SecretProjection":{"description":"Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional field specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.KeyToPath":{"description":"Maps a string key to a path within a volume.","required":["key","path"],"properties":{"key":{"description":"key is the key to project.","type":"string"},"mode":{"description":"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.","type":"string"}}}}}} ``` ## The v1.SecretVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.SecretVolumeSource":{"description":"Adapts a Secret into a volume.\n\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"optional":{"description":"optional field specify whether the Secret or its keys must be defined","type":"boolean"},"secretName":{"description":"secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","type":"string"}}},"v1.KeyToPath":{"description":"Maps a string key to a path within a volume.","required":["key","path"],"properties":{"key":{"description":"key is the key to project.","type":"string"},"mode":{"description":"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.","type":"string"}}}}}} ``` ## The v1.SecurityContext object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.SecurityContext":{"description":"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.","properties":{"allowPrivilegeEscalation":{"description":"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"capabilities":{"description":"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.Capabilities"},"privileged":{"description":"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"procMount":{"description":"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"readOnlyRootFilesystem":{"description":"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Capabilities":{"description":"Adds and removes POSIX capabilities from running containers.","properties":{"add":{"description":"Added capabilities","type":"array","items":{"type":"string"}},"drop":{"description":"Removed capabilities","type":"array","items":{"type":"string"}}}},"v1.SELinuxOptions":{"description":"SELinuxOptions are the labels to be applied to the container","properties":{"level":{"description":"Level is SELinux level label that applies to the container.","type":"string"},"role":{"description":"Role is a SELinux role label that applies to the container.","type":"string"},"type":{"description":"Type is a SELinux type label that applies to the container.","type":"string"},"user":{"description":"User is a SELinux user label that applies to the container.","type":"string"}}},"v1.SeccompProfile":{"description":"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.","required":["type"],"properties":{"localhostProfile":{"description":"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is \"Localhost\".","type":"string"},"type":{"description":"type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.","type":"string"}}},"v1.WindowsSecurityContextOptions":{"description":"WindowsSecurityContextOptions contain Windows-specific options and credentials.","properties":{"gmsaCredentialSpec":{"description":"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.","type":"string"},"gmsaCredentialSpecName":{"description":"GMSACredentialSpecName is the name of the GMSA credential spec to use.","type":"string"},"hostProcess":{"description":"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.","type":"boolean"},"runAsUserName":{"description":"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"string"}}}}}} ``` ## The v1.ServiceAccountTokenProjection object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.ServiceAccountTokenProjection":{"description":"ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).","required":["path"],"properties":{"audience":{"description":"audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.","type":"string"},"expirationSeconds":{"description":"expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.","type":"integer","format":"int64"},"path":{"description":"path is the path relative to the mount point of the file to project the token into.","type":"string"}}}}}} ``` ## The v1.StorageOSVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.StorageOSVolumeSource":{"description":"Represents a StorageOS persistent volume resource.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeName":{"description":"volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.","type":"string"},"volumeNamespace":{"description":"volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.","type":"string"}}},"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}}}}} ``` ## The v1.Sysctl object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.Sysctl":{"description":"Sysctl defines a kernel parameter to be set","required":["name","value"],"properties":{"name":{"description":"Name of a property to set","type":"string"},"value":{"description":"Value of a property to set","type":"string"}}}}}} ``` ## The v1.TCPSocketAction object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.TCPSocketAction":{"description":"TCPSocketAction describes an action based on opening a socket","required":["port"],"properties":{"host":{"description":"Optional: Host name to connect to, defaults to the pod IP.","type":"string"},"port":{"description":"Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}}}}} ``` ## The v1.Time object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}}}}} ``` ## The v1.Toleration object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.Toleration":{"description":"The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .","properties":{"effect":{"description":"Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.","type":"string"},"key":{"description":"Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.","type":"string"},"operator":{"description":"Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.","type":"string"},"tolerationSeconds":{"description":"TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.","type":"integer","format":"int64"},"value":{"description":"Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.","type":"string"}}}}}} ``` ## The v1.TypedLocalObjectReference object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.TypedLocalObjectReference":{"description":"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.","required":["apiGroup","kind","name"],"properties":{"apiGroup":{"description":"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.","type":"string"},"kind":{"description":"Kind is the type of resource being referenced","type":"string"},"name":{"description":"Name is the name of resource being referenced","type":"string"}}}}}} ``` ## The v1.Volume object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.Volume":{"description":"Volume represents a named volume in a pod that may be accessed by any container in the pod.","required":["name"],"properties":{"awsElasticBlockStore":{"description":"awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","$ref":"#/components/schemas/v1.AWSElasticBlockStoreVolumeSource"},"azureDisk":{"description":"azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureDiskVolumeSource"},"azureFile":{"description":"azureFile represents an Azure File Service mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureFileVolumeSource"},"cephfs":{"description":"cephFS represents a Ceph FS mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.CephFSVolumeSource"},"cinder":{"description":"cinder represents a cinder volume attached and mounted on kubelets host machine. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","$ref":"#/components/schemas/v1.CinderVolumeSource"},"configMap":{"description":"configMap represents a configMap that should populate this volume","$ref":"#/components/schemas/v1.ConfigMapVolumeSource"},"csi":{"description":"csi (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers (Beta feature).","$ref":"#/components/schemas/v1.CSIVolumeSource"},"downwardAPI":{"description":"downwardAPI represents downward API about the pod that should populate this volume","$ref":"#/components/schemas/v1.DownwardAPIVolumeSource"},"emptyDir":{"description":"emptyDir represents a temporary directory that shares a pod's lifetime. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","$ref":"#/components/schemas/v1.EmptyDirVolumeSource"},"ephemeral":{"description":"ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed.\n\nUse this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity\n tracking are needed,\nc) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through\n a PersistentVolumeClaim (see EphemeralVolumeSource for more\n information on the connection between this volume type\n and PersistentVolumeClaim).\n\nUse PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod.\n\nUse CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information.\n\nA pod can use both types of ephemeral volumes and persistent volumes at the same time.","$ref":"#/components/schemas/v1.EphemeralVolumeSource"},"fc":{"description":"fc represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.","$ref":"#/components/schemas/v1.FCVolumeSource"},"flexVolume":{"description":"flexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","$ref":"#/components/schemas/v1.FlexVolumeSource"},"flocker":{"description":"flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running","$ref":"#/components/schemas/v1.FlockerVolumeSource"},"gcePersistentDisk":{"description":"gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","$ref":"#/components/schemas/v1.GCEPersistentDiskVolumeSource"},"gitRepo":{"description":"gitRepo represents a git repository at a particular revision. DEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","$ref":"#/components/schemas/v1.GitRepoVolumeSource"},"glusterfs":{"description":"glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/glusterfs/README.md","$ref":"#/components/schemas/v1.GlusterfsVolumeSource"},"hostPath":{"description":"hostPath represents a pre-existing file or directory on the host machine that is directly exposed to the container. This is generally used for system agents or other privileged things that are allowed to see the host machine. Most containers will NOT need this. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","$ref":"#/components/schemas/v1.HostPathVolumeSource"},"iscsi":{"description":"iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://examples.k8s.io/volumes/iscsi/README.md","$ref":"#/components/schemas/v1.ISCSIVolumeSource"},"name":{"description":"name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"nfs":{"description":"nfs represents an NFS mount on the host that shares a pod's lifetime More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","$ref":"#/components/schemas/v1.NFSVolumeSource"},"persistentVolumeClaim":{"description":"persistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimVolumeSource"},"photonPersistentDisk":{"description":"photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PhotonPersistentDiskVolumeSource"},"portworxVolume":{"description":"portworxVolume represents a portworx volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PortworxVolumeSource"},"projected":{"description":"projected items for all in one resources secrets, configmaps, and downward API","$ref":"#/components/schemas/v1.ProjectedVolumeSource"},"quobyte":{"description":"quobyte represents a Quobyte mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.QuobyteVolumeSource"},"rbd":{"description":"rbd represents a Rados Block Device mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/rbd/README.md","$ref":"#/components/schemas/v1.RBDVolumeSource"},"scaleIO":{"description":"scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.ScaleIOVolumeSource"},"secret":{"description":"secret represents a secret that should populate this volume. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","$ref":"#/components/schemas/v1.SecretVolumeSource"},"storageos":{"description":"storageOS represents a StorageOS volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.StorageOSVolumeSource"},"vsphereVolume":{"description":"vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.VsphereVirtualDiskVolumeSource"}}},"v1.AWSElasticBlockStoreVolumeSource":{"description":"Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).","type":"integer","format":"int32"},"readOnly":{"description":"readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"boolean"},"volumeID":{"description":"volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"}}},"v1.AzureDiskVolumeSource":{"description":"AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","required":["diskName","diskURI"],"properties":{"cachingMode":{"description":"cachingMode is the Host Caching mode: None, Read Only, Read Write.","type":"string"},"diskName":{"description":"diskName is the Name of the data disk in the blob storage","type":"string"},"diskURI":{"description":"diskURI is the URI of data disk in the blob storage","type":"string"},"fsType":{"description":"fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"kind":{"description":"kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"}}},"v1.AzureFileVolumeSource":{"description":"AzureFile represents an Azure File Service mount on the host and bind mount to the pod.","required":["secretName","shareName"],"properties":{"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretName":{"description":"secretName is the name of secret that contains Azure Storage Account Name and Key","type":"string"},"shareName":{"description":"shareName is the azure share Name","type":"string"}}},"v1.CephFSVolumeSource":{"description":"Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.","required":["monitors"],"properties":{"monitors":{"description":"monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"path":{"description":"path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /","type":"string"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"boolean"},"secretFile":{"description":"secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"},"secretRef":{"description":"secretRef is Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"}}},"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}},"v1.CinderVolumeSource":{"description":"Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"boolean"},"secretRef":{"description":"secretRef is optional: points to a secret object containing parameters used to connect to OpenStack.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeID":{"description":"volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"}}},"v1.ConfigMapVolumeSource":{"description":"Adapts a ConfigMap into a volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.KeyToPath":{"description":"Maps a string key to a path within a volume.","required":["key","path"],"properties":{"key":{"description":"key is the key to project.","type":"string"},"mode":{"description":"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.","type":"string"}}},"v1.CSIVolumeSource":{"description":"Represents a source location of a volume to mount, managed by an external CSI driver","required":["driver"],"properties":{"driver":{"description":"driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.","type":"string"},"fsType":{"description":"fsType to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.","type":"string"},"nodePublishSecretRef":{"description":"nodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secret references are passed.","$ref":"#/components/schemas/v1.LocalObjectReference"},"readOnly":{"description":"readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).","type":"boolean"},"volumeAttributes":{"description":"volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.","type":"object","additionalProperties":{"type":"string"}}}},"v1.DownwardAPIVolumeSource":{"description":"DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"Items is a list of downward API volume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.DownwardAPIVolumeFile":{"description":"DownwardAPIVolumeFile represents information to create the file containing the pod field","required":["path"],"properties":{"fieldRef":{"description":"Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"mode":{"description":"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'","type":"string"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.EmptyDirVolumeSource":{"description":"Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.","properties":{"medium":{"description":"medium represents what type of storage medium should back this directory. The default is \"\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","type":"string"},"sizeLimit":{"description":"sizeLimit is the total amount of local storage required for this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. The default is nil which means that the limit is undefined. More info: http://kubernetes.io/docs/user-guide/volumes#emptydir","$ref":"#/components/schemas/resource.Quantity"}}},"v1.EphemeralVolumeSource":{"description":"Represents an ephemeral volume that is handled by a normal storage driver.","properties":{"volumeClaimTemplate":{"description":"Will be used to create a stand-alone PVC to provision the volume. The pod in which this EphemeralVolumeSource is embedded will be the owner of the PVC, i.e. the PVC will be deleted together with the pod. The name of the PVC will be `-` where `` is the name from the `PodSpec.Volumes` array entry. Pod validation will reject the pod if the concatenated name is not valid for a PVC (for example, too long).\n\nAn existing PVC with that name that is not owned by the pod will *not* be used for the pod to avoid using an unrelated volume by mistake. Starting the pod is then blocked until the unrelated PVC is removed. If such a pre-created PVC is meant to be used by the pod, the PVC has to updated with an owner reference to the pod once the pod exists. Normally this should not be necessary, but it may be useful when manually reconstructing a broken cluster.\n\nThis field is read-only and no changes will be made by Kubernetes to the PVC after it has been created.\n\nRequired, must not be nil.","$ref":"#/components/schemas/v1.PersistentVolumeClaimTemplate"}}},"v1.PersistentVolumeClaimTemplate":{"description":"PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.","required":["spec"],"properties":{"metadata":{"description":"May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"The specification for the PersistentVolumeClaim. The entire content is copied unchanged into the PVC that gets created from this template. The same fields as in a PersistentVolumeClaim are also valid here.","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"}}},"v1.ObjectMeta":{"description":"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.","properties":{"annotations":{"description":"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations","type":"object","additionalProperties":{"type":"string"}},"clusterName":{"description":"Deprecated: ClusterName is a legacy field that was always cleared by the system and never used; it will be removed completely in 1.25.\n\nThe name in the go struct is changed to help clients detect accidental use.","type":"string"},"creationTimestamp":{"description":"CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"deletionGracePeriodSeconds":{"description":"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.","type":"integer","format":"int64"},"deletionTimestamp":{"description":"DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"finalizers":{"description":"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.","type":"array","items":{"type":"string"}},"generateName":{"description":"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency","type":"string"},"generation":{"description":"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.","type":"integer","format":"int64"},"labels":{"description":"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels","type":"object","additionalProperties":{"type":"string"}},"managedFields":{"description":"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.","type":"array","items":{"$ref":"#/components/schemas/v1.ManagedFieldsEntry"}},"name":{"description":"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"namespace":{"description":"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces","type":"string"},"ownerReferences":{"description":"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.","type":"array","items":{"$ref":"#/components/schemas/v1.OwnerReference"}},"resourceVersion":{"description":"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency","type":"string"},"selfLink":{"description":"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.","type":"string"},"uid":{"description":"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}},"v1.ManagedFieldsEntry":{"description":"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.","properties":{"apiVersion":{"description":"APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.","type":"string"},"fieldsType":{"description":"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"","type":"string"},"fieldsV1":{"description":"FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type.","$ref":"#/components/schemas/v1.FieldsV1"},"manager":{"description":"Manager is an identifier of the workflow managing these fields.","type":"string"},"operation":{"description":"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.","type":"string"},"subresource":{"description":"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.","type":"string"},"time":{"description":"Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over.","$ref":"#/components/schemas/v1.Time"}}},"v1.FieldsV1":{"description":"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff"},"v1.OwnerReference":{"description":"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.","required":["apiVersion","kind","name","uid"],"properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"blockOwnerDeletion":{"description":"If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.","type":"boolean"},"controller":{"description":"If true, this reference points to the managing controller.","type":"boolean"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"uid":{"description":"UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.PersistentVolumeClaimSpec":{"description":"PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes","properties":{"accessModes":{"description":"accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"dataSource":{"description":"dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"dataSourceRef":{"description":"dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"resources":{"description":"resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources","$ref":"#/components/schemas/v1.ResourceRequirements"},"selector":{"description":"selector is a label query over volumes to consider for binding.","$ref":"#/components/schemas/v1.LabelSelector"},"storageClassName":{"description":"storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1","type":"string"},"volumeMode":{"description":"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.","type":"string"},"volumeName":{"description":"volumeName is the binding reference to the PersistentVolume backing this claim.","type":"string"}}},"v1.TypedLocalObjectReference":{"description":"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.","required":["apiGroup","kind","name"],"properties":{"apiGroup":{"description":"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.","type":"string"},"kind":{"description":"Kind is the type of resource being referenced","type":"string"},"name":{"description":"Name is the name of resource being referenced","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.FCVolumeSource":{"description":"Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"lun":{"description":"lun is Optional: FC target lun number","type":"integer","format":"int32"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"targetWWNs":{"description":"targetWWNs is Optional: FC target worldwide names (WWNs)","type":"array","items":{"type":"string"}},"wwids":{"description":"wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.","type":"array","items":{"type":"string"}}}},"v1.FlexVolumeSource":{"description":"FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","required":["driver"],"properties":{"driver":{"description":"driver is the name of the driver to use for this volume.","type":"string"},"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.","type":"string"},"options":{"description":"options is Optional: this field holds extra command options if any.","type":"object","additionalProperties":{"type":"string"}},"readOnly":{"description":"readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef is Optional: secretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts.","$ref":"#/components/schemas/v1.LocalObjectReference"}}},"v1.FlockerVolumeSource":{"description":"Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.","properties":{"datasetName":{"description":"datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated","type":"string"},"datasetUUID":{"description":"datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset","type":"string"}}},"v1.GCEPersistentDiskVolumeSource":{"description":"Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.","required":["pdName"],"properties":{"fsType":{"description":"fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"integer","format":"int32"},"pdName":{"description":"pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"boolean"}}},"v1.GitRepoVolumeSource":{"description":"Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","required":["repository"],"properties":{"directory":{"description":"directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.","type":"string"},"repository":{"description":"repository is the URL","type":"string"},"revision":{"description":"revision is the commit hash for the specified revision.","type":"string"}}},"v1.GlusterfsVolumeSource":{"description":"Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.","required":["endpoints","path"],"properties":{"endpoints":{"description":"endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"path":{"description":"path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"readOnly":{"description":"readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"boolean"}}},"v1.HostPathVolumeSource":{"description":"Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.","required":["path"],"properties":{"path":{"description":"path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"},"type":{"description":"type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"}}},"v1.ISCSIVolumeSource":{"description":"Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.","required":["targetPortal","iqn","lun"],"properties":{"chapAuthDiscovery":{"description":"chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication","type":"boolean"},"chapAuthSession":{"description":"chapAuthSession defines whether support iSCSI Session CHAP authentication","type":"boolean"},"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi","type":"string"},"initiatorName":{"description":"initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.","type":"string"},"iqn":{"description":"iqn is the target iSCSI Qualified Name.","type":"string"},"iscsiInterface":{"description":"iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).","type":"string"},"lun":{"description":"lun represents iSCSI Target Lun number.","type":"integer","format":"int32"},"portals":{"description":"portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"array","items":{"type":"string"}},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.","type":"boolean"},"secretRef":{"description":"secretRef is the CHAP Secret for iSCSI target and initiator authentication","$ref":"#/components/schemas/v1.LocalObjectReference"},"targetPortal":{"description":"targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"string"}}},"v1.NFSVolumeSource":{"description":"Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.","required":["server","path"],"properties":{"path":{"description":"path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"},"readOnly":{"description":"readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"boolean"},"server":{"description":"server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"}}},"v1.PersistentVolumeClaimVolumeSource":{"description":"PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).","required":["claimName"],"properties":{"claimName":{"description":"claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","type":"string"},"readOnly":{"description":"readOnly Will force the ReadOnly setting in VolumeMounts. Default false.","type":"boolean"}}},"v1.PhotonPersistentDiskVolumeSource":{"description":"Represents a Photon Controller persistent disk resource.","required":["pdID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"pdID":{"description":"pdID is the ID that identifies Photon Controller persistent disk","type":"string"}}},"v1.PortworxVolumeSource":{"description":"PortworxVolumeSource represents a Portworx volume resource.","required":["volumeID"],"properties":{"fsType":{"description":"fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"volumeID":{"description":"volumeID uniquely identifies a Portworx volume","type":"string"}}},"v1.ProjectedVolumeSource":{"description":"Represents a projected volume source","required":["sources"],"properties":{"defaultMode":{"description":"defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"sources":{"description":"sources is the list of volume projections","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeProjection"}}}},"v1.VolumeProjection":{"description":"Projection that may be projected along with other supported volume types","properties":{"configMap":{"description":"configMap information about the configMap data to project","$ref":"#/components/schemas/v1.ConfigMapProjection"},"downwardAPI":{"description":"downwardAPI information about the downwardAPI data to project","$ref":"#/components/schemas/v1.DownwardAPIProjection"},"secret":{"description":"secret information about the secret data to project","$ref":"#/components/schemas/v1.SecretProjection"},"serviceAccountToken":{"description":"serviceAccountToken is information about the serviceAccountToken data to project","$ref":"#/components/schemas/v1.ServiceAccountTokenProjection"}}},"v1.ConfigMapProjection":{"description":"Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.DownwardAPIProjection":{"description":"Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.","properties":{"items":{"description":"Items is a list of DownwardAPIVolume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.SecretProjection":{"description":"Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional field specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.ServiceAccountTokenProjection":{"description":"ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).","required":["path"],"properties":{"audience":{"description":"audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.","type":"string"},"expirationSeconds":{"description":"expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.","type":"integer","format":"int64"},"path":{"description":"path is the path relative to the mount point of the file to project the token into.","type":"string"}}},"v1.QuobyteVolumeSource":{"description":"Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.","required":["registry","volume"],"properties":{"group":{"description":"group to map volume access to Default is no group","type":"string"},"readOnly":{"description":"readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.","type":"boolean"},"registry":{"description":"registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes","type":"string"},"tenant":{"description":"tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin","type":"string"},"user":{"description":"user to map volume access to Defaults to serivceaccount user","type":"string"},"volume":{"description":"volume is a string that references an already created Quobyte volume by name.","type":"string"}}},"v1.RBDVolumeSource":{"description":"Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.","required":["monitors","image"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd","type":"string"},"image":{"description":"image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"keyring":{"description":"keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"monitors":{"description":"monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"pool":{"description":"pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"boolean"},"secretRef":{"description":"secretRef is name of the authentication secret for RBDUser. If provided overrides keyring. Default is nil. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"}}},"v1.ScaleIOVolumeSource":{"description":"ScaleIOVolumeSource represents a persistent ScaleIO volume","required":["gateway","system","secretRef"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\".","type":"string"},"gateway":{"description":"gateway is the host address of the ScaleIO API Gateway.","type":"string"},"protectionDomain":{"description":"protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef references to the secret for ScaleIO user and other sensitive information. If this is not provided, Login operation will fail.","$ref":"#/components/schemas/v1.LocalObjectReference"},"sslEnabled":{"description":"sslEnabled Flag enable/disable SSL communication with Gateway, default false","type":"boolean"},"storageMode":{"description":"storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.","type":"string"},"storagePool":{"description":"storagePool is the ScaleIO Storage Pool associated with the protection domain.","type":"string"},"system":{"description":"system is the name of the storage system as configured in ScaleIO.","type":"string"},"volumeName":{"description":"volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.","type":"string"}}},"v1.SecretVolumeSource":{"description":"Adapts a Secret into a volume.\n\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"optional":{"description":"optional field specify whether the Secret or its keys must be defined","type":"boolean"},"secretName":{"description":"secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","type":"string"}}},"v1.StorageOSVolumeSource":{"description":"Represents a StorageOS persistent volume resource.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeName":{"description":"volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.","type":"string"},"volumeNamespace":{"description":"volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.","type":"string"}}},"v1.VsphereVirtualDiskVolumeSource":{"description":"Represents a vSphere volume resource.","required":["volumePath"],"properties":{"fsType":{"description":"fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"storagePolicyID":{"description":"storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.","type":"string"},"storagePolicyName":{"description":"storagePolicyName is the storage Policy Based Management (SPBM) profile name.","type":"string"},"volumePath":{"description":"volumePath is the path that identifies vSphere volume vmdk","type":"string"}}}}}} ``` ## The v1.VolumeDevice object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.VolumeDevice":{"description":"volumeDevice describes a mapping of a raw block device within a container.","required":["name","devicePath"],"properties":{"devicePath":{"description":"devicePath is the path inside of the container that the device will be mapped to.","type":"string"},"name":{"description":"name must match the name of a persistentVolumeClaim in the pod","type":"string"}}}}}} ``` ## The v1.VolumeMount object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.VolumeMount":{"description":"VolumeMount describes a mounting of a Volume within a container.","required":["name","mountPath"],"properties":{"mountPath":{"description":"Path within the container at which the volume should be mounted. Must not contain ':'.","type":"string"},"mountPropagation":{"description":"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10.","type":"string"},"name":{"description":"This must match the Name of a Volume.","type":"string"},"readOnly":{"description":"Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.","type":"boolean"},"subPath":{"description":"Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).","type":"string"},"subPathExpr":{"description":"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.","type":"string"}}}}}} ``` ## The v1.VolumeProjection object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.VolumeProjection":{"description":"Projection that may be projected along with other supported volume types","properties":{"configMap":{"description":"configMap information about the configMap data to project","$ref":"#/components/schemas/v1.ConfigMapProjection"},"downwardAPI":{"description":"downwardAPI information about the downwardAPI data to project","$ref":"#/components/schemas/v1.DownwardAPIProjection"},"secret":{"description":"secret information about the secret data to project","$ref":"#/components/schemas/v1.SecretProjection"},"serviceAccountToken":{"description":"serviceAccountToken is information about the serviceAccountToken data to project","$ref":"#/components/schemas/v1.ServiceAccountTokenProjection"}}},"v1.ConfigMapProjection":{"description":"Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.KeyToPath":{"description":"Maps a string key to a path within a volume.","required":["key","path"],"properties":{"key":{"description":"key is the key to project.","type":"string"},"mode":{"description":"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.","type":"string"}}},"v1.DownwardAPIProjection":{"description":"Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.","properties":{"items":{"description":"Items is a list of DownwardAPIVolume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.DownwardAPIVolumeFile":{"description":"DownwardAPIVolumeFile represents information to create the file containing the pod field","required":["path"],"properties":{"fieldRef":{"description":"Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"mode":{"description":"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'","type":"string"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.SecretProjection":{"description":"Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional field specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.ServiceAccountTokenProjection":{"description":"ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).","required":["path"],"properties":{"audience":{"description":"audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.","type":"string"},"expirationSeconds":{"description":"expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.","type":"integer","format":"int64"},"path":{"description":"path is the path relative to the mount point of the file to project the token into.","type":"string"}}}}}} ``` ## The v1.VsphereVirtualDiskVolumeSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.VsphereVirtualDiskVolumeSource":{"description":"Represents a vSphere volume resource.","required":["volumePath"],"properties":{"fsType":{"description":"fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"storagePolicyID":{"description":"storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.","type":"string"},"storagePolicyName":{"description":"storagePolicyName is the storage Policy Based Management (SPBM) profile name.","type":"string"},"volumePath":{"description":"volumePath is the path that identifies vSphere volume vmdk","type":"string"}}}}}} ``` ## The v1.WeightedPodAffinityTerm object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.WeightedPodAffinityTerm":{"description":"The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)","required":["weight","podAffinityTerm"],"properties":{"podAffinityTerm":{"description":"Required. A pod affinity term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.PodAffinityTerm"},"weight":{"description":"weight associated with matching the corresponding podAffinityTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.PodAffinityTerm":{"description":"Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running","required":["topologyKey"],"properties":{"labelSelector":{"description":"A label query over a set of resources, in this case pods.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaceSelector":{"description":"A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means \"this pod's namespace\". An empty selector ({}) matches all namespaces.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaces":{"description":"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".","type":"array","items":{"type":"string"}},"topologyKey":{"description":"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.","type":"string"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}}}}} ``` ## The v1.WindowsSecurityContextOptions object ```json {"openapi":"3.1.1","components":{"schemas":{"v1.WindowsSecurityContextOptions":{"description":"WindowsSecurityContextOptions contain Windows-specific options and credentials.","properties":{"gmsaCredentialSpec":{"description":"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.","type":"string"},"gmsaCredentialSpecName":{"description":"GMSACredentialSpecName is the name of the GMSA credential spec to use.","type":"string"},"hostProcess":{"description":"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.","type":"boolean"},"runAsUserName":{"description":"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"string"}}}}}} ``` ## The v1alpha1.ArchiveStrategy object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{}}}} ``` ## The v1alpha1.Amount object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Amount":{}}}} ``` ## The v1alpha1.Arguments object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Arguments":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Artifact":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.Parameter":{"required":["name"],"properties":{"default":{"type":"string"},"description":{"type":"string"},"enum":{"type":"array","items":{"type":"string"}},"globalName":{"type":"string"},"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.ValueFrom"}}},"v1alpha1.ValueFrom":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"default":{"type":"string"},"event":{"type":"string"},"expression":{"type":"string"},"jqFilter":{"type":"string"},"jsonPath":{"type":"string"},"parameter":{"type":"string"},"path":{"type":"string"},"supplied":{"$ref":"#/components/schemas/v1alpha1.SuppliedValueFrom"}}},"v1alpha1.SuppliedValueFrom":{}}}} ``` ## The v1alpha1.ArtGCStatus object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ArtGCStatus":{"properties":{"notSpecified":{"type":"boolean"},"podsRecouped":{"type":"object","additionalProperties":{"type":"boolean"}},"strategiesProcessed":{"type":"object","additionalProperties":{"type":"boolean"}}}}}}} ``` ## The v1alpha1.Artifact object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Artifact":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}}}}} ``` ## The v1alpha1.ArtifactGC object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}}}}} ``` ## The v1alpha1.ArtifactLocation object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ArtifactLocation":{"properties":{"archiveLogs":{"type":"boolean"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}}}}} ``` ## The v1alpha1.ArtifactPaths object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ArtifactPaths":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}}}}} ``` ## The v1alpha1.ArtifactRepository object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ArtifactRepository":{"properties":{"archiveLogs":{"type":"boolean"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifactRepository"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifactRepository"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifactRepository"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifactRepository"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifactRepository"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3ArtifactRepository"}}},"v1alpha1.ArtifactoryArtifactRepository":{"properties":{"keyFormat":{"type":"string"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repoURL":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifactRepository":{"required":["endpoint","container"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blobNameFormat":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifactRepository":{"properties":{"bucket":{"type":"string"},"keyFormat":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifactRepository":{"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"pathFormat":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.OSSArtifactRepository":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"keyFormat":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.S3ArtifactRepository":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"keyFormat":{"type":"string"},"keyPrefix":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}}}}} ``` ## The v1alpha1.ArtifactRepositoryRef object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ArtifactRepositoryRef":{"properties":{"configMap":{"type":"string"},"key":{"type":"string"}}}}}} ``` ## The v1alpha1.ArtifactRepositoryRefStatus object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ArtifactRepositoryRefStatus":{"properties":{"artifactRepository":{"$ref":"#/components/schemas/v1alpha1.ArtifactRepository"},"configMap":{"type":"string"},"default":{"type":"boolean"},"key":{"type":"string"},"namespace":{"type":"string"}}},"v1alpha1.ArtifactRepository":{"properties":{"archiveLogs":{"type":"boolean"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifactRepository"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifactRepository"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifactRepository"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifactRepository"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifactRepository"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3ArtifactRepository"}}},"v1alpha1.ArtifactoryArtifactRepository":{"properties":{"keyFormat":{"type":"string"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repoURL":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifactRepository":{"required":["endpoint","container"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blobNameFormat":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifactRepository":{"properties":{"bucket":{"type":"string"},"keyFormat":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifactRepository":{"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"pathFormat":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.OSSArtifactRepository":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"keyFormat":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.S3ArtifactRepository":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"keyFormat":{"type":"string"},"keyPrefix":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}}}}} ``` ## The v1alpha1.ArtifactoryArtifact object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}}}}} ``` ## The v1alpha1.ArtifactoryArtifactRepository object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ArtifactoryArtifactRepository":{"properties":{"keyFormat":{"type":"string"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repoURL":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}}}}} ``` ## The v1alpha1.AzureArtifact object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}}}}} ``` ## The v1alpha1.AzureArtifactRepository object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.AzureArtifactRepository":{"required":["endpoint","container"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blobNameFormat":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}}}}} ``` ## The v1alpha1.Backoff object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Backoff":{"properties":{"duration":{"type":"string"},"factor":{"$ref":"#/components/schemas/intstr.IntOrString"},"maxDuration":{"type":"string"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}}}}} ``` ## The v1alpha1.BasicAuth object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}}}}} ``` ## The v1alpha1.Cache object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Cache":{"required":["configMap"],"properties":{"configMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}}}}} ``` ## The v1alpha1.ClientCertAuth object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}}}}} ``` ## The v1alpha1.Condition object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Condition":{"properties":{"message":{"type":"string"},"status":{"type":"string"},"type":{"type":"string"}}}}}} ``` ## The v1alpha1.ContainerNode object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ContainerNode":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"dependencies":{"type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1.EnvVar":{"description":"EnvVar represents an environment variable present in a Container.","required":["name"],"properties":{"name":{"description":"Name of the environment variable. Must be a C_IDENTIFIER.","type":"string"},"value":{"description":"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".","type":"string"},"valueFrom":{"description":"Source for the environment variable's value. Cannot be used if value is not empty.","$ref":"#/components/schemas/v1.EnvVarSource"}}},"v1.EnvVarSource":{"description":"EnvVarSource represents a source for the value of an EnvVar.","properties":{"configMapKeyRef":{"description":"Selects a key of a ConfigMap.","$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"fieldRef":{"description":"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"},"secretKeyRef":{"description":"Selects a key of a secret in the pod's namespace","$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.EnvFromSource":{"description":"EnvFromSource represents the source of a set of ConfigMaps","properties":{"configMapRef":{"description":"The ConfigMap to select from","$ref":"#/components/schemas/v1.ConfigMapEnvSource"},"prefix":{"description":"An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.","type":"string"},"secretRef":{"description":"The Secret to select from","$ref":"#/components/schemas/v1.SecretEnvSource"}}},"v1.ConfigMapEnvSource":{"description":"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap must be defined","type":"boolean"}}},"v1.SecretEnvSource":{"description":"SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret must be defined","type":"boolean"}}},"v1.Lifecycle":{"description":"Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.","properties":{"postStart":{"description":"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"},"preStop":{"description":"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"}}},"v1.LifecycleHandler":{"description":"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"tcpSocket":{"description":"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.","$ref":"#/components/schemas/v1.TCPSocketAction"}}},"v1.ExecAction":{"description":"ExecAction describes a \"run in container\" action.","properties":{"command":{"description":"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.","type":"array","items":{"type":"string"}}}},"v1.HTTPGetAction":{"description":"HTTPGetAction describes an action based on HTTP Get requests.","required":["port"],"properties":{"host":{"description":"Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.","type":"string"},"httpHeaders":{"description":"Custom headers to set in the request. HTTP allows repeated headers.","type":"array","items":{"$ref":"#/components/schemas/v1.HTTPHeader"}},"path":{"description":"Path to access on the HTTP server.","type":"string"},"port":{"description":"Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"},"scheme":{"description":"Scheme to use for connecting to the host. Defaults to HTTP.","type":"string"}}},"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}},"v1.TCPSocketAction":{"description":"TCPSocketAction describes an action based on opening a socket","required":["port"],"properties":{"host":{"description":"Optional: Host name to connect to, defaults to the pod IP.","type":"string"},"port":{"description":"Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"}}},"v1.Probe":{"description":"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"failureThreshold":{"description":"Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.","type":"integer","format":"int32"},"grpc":{"description":"GRPC specifies an action involving a GRPC port. This is a beta field and requires enabling GRPCContainerProbe feature gate.","$ref":"#/components/schemas/v1.GRPCAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"initialDelaySeconds":{"description":"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"},"periodSeconds":{"description":"How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.","type":"integer","format":"int32"},"successThreshold":{"description":"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.","type":"integer","format":"int32"},"tcpSocket":{"description":"TCPSocket specifies an action involving a TCP port.","$ref":"#/components/schemas/v1.TCPSocketAction"},"terminationGracePeriodSeconds":{"description":"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.","type":"integer","format":"int64"},"timeoutSeconds":{"description":"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"}}},"v1.GRPCAction":{"required":["port","service"],"properties":{"port":{"description":"Port number of the gRPC service. Number must be in the range 1 to 65535.","type":"integer","format":"int32"},"service":{"description":"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.","type":"string"}}},"v1.ContainerPort":{"description":"ContainerPort represents a network port in a single container.","required":["containerPort"],"properties":{"containerPort":{"description":"Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.","type":"integer","format":"int32"},"hostIP":{"description":"What host IP to bind the external port to.","type":"string"},"hostPort":{"description":"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.","type":"integer","format":"int32"},"name":{"description":"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.","type":"string"},"protocol":{"description":"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"v1.SecurityContext":{"description":"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.","properties":{"allowPrivilegeEscalation":{"description":"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"capabilities":{"description":"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.Capabilities"},"privileged":{"description":"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"procMount":{"description":"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"readOnlyRootFilesystem":{"description":"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Capabilities":{"description":"Adds and removes POSIX capabilities from running containers.","properties":{"add":{"description":"Added capabilities","type":"array","items":{"type":"string"}},"drop":{"description":"Removed capabilities","type":"array","items":{"type":"string"}}}},"v1.SELinuxOptions":{"description":"SELinuxOptions are the labels to be applied to the container","properties":{"level":{"description":"Level is SELinux level label that applies to the container.","type":"string"},"role":{"description":"Role is a SELinux role label that applies to the container.","type":"string"},"type":{"description":"Type is a SELinux type label that applies to the container.","type":"string"},"user":{"description":"User is a SELinux user label that applies to the container.","type":"string"}}},"v1.SeccompProfile":{"description":"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.","required":["type"],"properties":{"localhostProfile":{"description":"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is \"Localhost\".","type":"string"},"type":{"description":"type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.","type":"string"}}},"v1.WindowsSecurityContextOptions":{"description":"WindowsSecurityContextOptions contain Windows-specific options and credentials.","properties":{"gmsaCredentialSpec":{"description":"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.","type":"string"},"gmsaCredentialSpecName":{"description":"GMSACredentialSpecName is the name of the GMSA credential spec to use.","type":"string"},"hostProcess":{"description":"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.","type":"boolean"},"runAsUserName":{"description":"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"string"}}},"v1.VolumeDevice":{"description":"volumeDevice describes a mapping of a raw block device within a container.","required":["name","devicePath"],"properties":{"devicePath":{"description":"devicePath is the path inside of the container that the device will be mapped to.","type":"string"},"name":{"description":"name must match the name of a persistentVolumeClaim in the pod","type":"string"}}},"v1.VolumeMount":{"description":"VolumeMount describes a mounting of a Volume within a container.","required":["name","mountPath"],"properties":{"mountPath":{"description":"Path within the container at which the volume should be mounted. Must not contain ':'.","type":"string"},"mountPropagation":{"description":"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10.","type":"string"},"name":{"description":"This must match the Name of a Volume.","type":"string"},"readOnly":{"description":"Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.","type":"boolean"},"subPath":{"description":"Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).","type":"string"},"subPathExpr":{"description":"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.","type":"string"}}}}}} ``` ## The v1alpha1.ContainerSetRetryStrategy object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ContainerSetRetryStrategy":{"required":["retries"],"properties":{"duration":{"type":"string"},"retries":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}}}}} ``` ## The v1alpha1.ContainerSetTemplate object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ContainerSetTemplate":{"required":["containers"],"properties":{"containers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ContainerNode"}},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.ContainerSetRetryStrategy"},"volumeMounts":{"type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}}}},"v1alpha1.ContainerNode":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"dependencies":{"type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1.EnvVar":{"description":"EnvVar represents an environment variable present in a Container.","required":["name"],"properties":{"name":{"description":"Name of the environment variable. Must be a C_IDENTIFIER.","type":"string"},"value":{"description":"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".","type":"string"},"valueFrom":{"description":"Source for the environment variable's value. Cannot be used if value is not empty.","$ref":"#/components/schemas/v1.EnvVarSource"}}},"v1.EnvVarSource":{"description":"EnvVarSource represents a source for the value of an EnvVar.","properties":{"configMapKeyRef":{"description":"Selects a key of a ConfigMap.","$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"fieldRef":{"description":"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"},"secretKeyRef":{"description":"Selects a key of a secret in the pod's namespace","$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.EnvFromSource":{"description":"EnvFromSource represents the source of a set of ConfigMaps","properties":{"configMapRef":{"description":"The ConfigMap to select from","$ref":"#/components/schemas/v1.ConfigMapEnvSource"},"prefix":{"description":"An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.","type":"string"},"secretRef":{"description":"The Secret to select from","$ref":"#/components/schemas/v1.SecretEnvSource"}}},"v1.ConfigMapEnvSource":{"description":"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap must be defined","type":"boolean"}}},"v1.SecretEnvSource":{"description":"SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret must be defined","type":"boolean"}}},"v1.Lifecycle":{"description":"Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.","properties":{"postStart":{"description":"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"},"preStop":{"description":"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"}}},"v1.LifecycleHandler":{"description":"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"tcpSocket":{"description":"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.","$ref":"#/components/schemas/v1.TCPSocketAction"}}},"v1.ExecAction":{"description":"ExecAction describes a \"run in container\" action.","properties":{"command":{"description":"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.","type":"array","items":{"type":"string"}}}},"v1.HTTPGetAction":{"description":"HTTPGetAction describes an action based on HTTP Get requests.","required":["port"],"properties":{"host":{"description":"Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.","type":"string"},"httpHeaders":{"description":"Custom headers to set in the request. HTTP allows repeated headers.","type":"array","items":{"$ref":"#/components/schemas/v1.HTTPHeader"}},"path":{"description":"Path to access on the HTTP server.","type":"string"},"port":{"description":"Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"},"scheme":{"description":"Scheme to use for connecting to the host. Defaults to HTTP.","type":"string"}}},"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}},"v1.TCPSocketAction":{"description":"TCPSocketAction describes an action based on opening a socket","required":["port"],"properties":{"host":{"description":"Optional: Host name to connect to, defaults to the pod IP.","type":"string"},"port":{"description":"Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"}}},"v1.Probe":{"description":"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"failureThreshold":{"description":"Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.","type":"integer","format":"int32"},"grpc":{"description":"GRPC specifies an action involving a GRPC port. This is a beta field and requires enabling GRPCContainerProbe feature gate.","$ref":"#/components/schemas/v1.GRPCAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"initialDelaySeconds":{"description":"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"},"periodSeconds":{"description":"How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.","type":"integer","format":"int32"},"successThreshold":{"description":"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.","type":"integer","format":"int32"},"tcpSocket":{"description":"TCPSocket specifies an action involving a TCP port.","$ref":"#/components/schemas/v1.TCPSocketAction"},"terminationGracePeriodSeconds":{"description":"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.","type":"integer","format":"int64"},"timeoutSeconds":{"description":"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"}}},"v1.GRPCAction":{"required":["port","service"],"properties":{"port":{"description":"Port number of the gRPC service. Number must be in the range 1 to 65535.","type":"integer","format":"int32"},"service":{"description":"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.","type":"string"}}},"v1.ContainerPort":{"description":"ContainerPort represents a network port in a single container.","required":["containerPort"],"properties":{"containerPort":{"description":"Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.","type":"integer","format":"int32"},"hostIP":{"description":"What host IP to bind the external port to.","type":"string"},"hostPort":{"description":"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.","type":"integer","format":"int32"},"name":{"description":"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.","type":"string"},"protocol":{"description":"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"v1.SecurityContext":{"description":"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.","properties":{"allowPrivilegeEscalation":{"description":"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"capabilities":{"description":"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.Capabilities"},"privileged":{"description":"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"procMount":{"description":"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"readOnlyRootFilesystem":{"description":"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Capabilities":{"description":"Adds and removes POSIX capabilities from running containers.","properties":{"add":{"description":"Added capabilities","type":"array","items":{"type":"string"}},"drop":{"description":"Removed capabilities","type":"array","items":{"type":"string"}}}},"v1.SELinuxOptions":{"description":"SELinuxOptions are the labels to be applied to the container","properties":{"level":{"description":"Level is SELinux level label that applies to the container.","type":"string"},"role":{"description":"Role is a SELinux role label that applies to the container.","type":"string"},"type":{"description":"Type is a SELinux type label that applies to the container.","type":"string"},"user":{"description":"User is a SELinux user label that applies to the container.","type":"string"}}},"v1.SeccompProfile":{"description":"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.","required":["type"],"properties":{"localhostProfile":{"description":"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is \"Localhost\".","type":"string"},"type":{"description":"type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.","type":"string"}}},"v1.WindowsSecurityContextOptions":{"description":"WindowsSecurityContextOptions contain Windows-specific options and credentials.","properties":{"gmsaCredentialSpec":{"description":"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.","type":"string"},"gmsaCredentialSpecName":{"description":"GMSACredentialSpecName is the name of the GMSA credential spec to use.","type":"string"},"hostProcess":{"description":"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.","type":"boolean"},"runAsUserName":{"description":"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"string"}}},"v1.VolumeDevice":{"description":"volumeDevice describes a mapping of a raw block device within a container.","required":["name","devicePath"],"properties":{"devicePath":{"description":"devicePath is the path inside of the container that the device will be mapped to.","type":"string"},"name":{"description":"name must match the name of a persistentVolumeClaim in the pod","type":"string"}}},"v1.VolumeMount":{"description":"VolumeMount describes a mounting of a Volume within a container.","required":["name","mountPath"],"properties":{"mountPath":{"description":"Path within the container at which the volume should be mounted. Must not contain ':'.","type":"string"},"mountPropagation":{"description":"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10.","type":"string"},"name":{"description":"This must match the Name of a Volume.","type":"string"},"readOnly":{"description":"Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.","type":"boolean"},"subPath":{"description":"Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).","type":"string"},"subPathExpr":{"description":"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.","type":"string"}}},"v1alpha1.ContainerSetRetryStrategy":{"required":["retries"],"properties":{"duration":{"type":"string"},"retries":{"$ref":"#/components/schemas/intstr.IntOrString"}}}}}} ``` ## The v1alpha1.ContinueOn object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ContinueOn":{"properties":{"error":{"type":"boolean"},"failed":{"type":"boolean"}}}}}} ``` ## The v1alpha1.Counter object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Counter":{"required":["value"],"properties":{"value":{"type":"string"}}}}}} ``` ## The v1alpha1.CreateS3BucketOptions object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}}}}} ``` ## The v1alpha1.CronWorkflow object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.CronWorkflow":{"required":["metadata","spec"],"properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"$ref":"#/components/schemas/v1alpha1.CronWorkflowSpec"},"status":{"$ref":"#/components/schemas/v1alpha1.CronWorkflowStatus"}}},"v1.ObjectMeta":{"description":"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.","properties":{"annotations":{"description":"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations","type":"object","additionalProperties":{"type":"string"}},"clusterName":{"description":"Deprecated: ClusterName is a legacy field that was always cleared by the system and never used; it will be removed completely in 1.25.\n\nThe name in the go struct is changed to help clients detect accidental use.","type":"string"},"creationTimestamp":{"description":"CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"deletionGracePeriodSeconds":{"description":"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.","type":"integer","format":"int64"},"deletionTimestamp":{"description":"DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"finalizers":{"description":"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.","type":"array","items":{"type":"string"}},"generateName":{"description":"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency","type":"string"},"generation":{"description":"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.","type":"integer","format":"int64"},"labels":{"description":"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels","type":"object","additionalProperties":{"type":"string"}},"managedFields":{"description":"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.","type":"array","items":{"$ref":"#/components/schemas/v1.ManagedFieldsEntry"}},"name":{"description":"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"namespace":{"description":"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces","type":"string"},"ownerReferences":{"description":"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.","type":"array","items":{"$ref":"#/components/schemas/v1.OwnerReference"}},"resourceVersion":{"description":"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency","type":"string"},"selfLink":{"description":"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.","type":"string"},"uid":{"description":"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}},"v1.ManagedFieldsEntry":{"description":"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.","properties":{"apiVersion":{"description":"APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.","type":"string"},"fieldsType":{"description":"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"","type":"string"},"fieldsV1":{"description":"FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type.","$ref":"#/components/schemas/v1.FieldsV1"},"manager":{"description":"Manager is an identifier of the workflow managing these fields.","type":"string"},"operation":{"description":"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.","type":"string"},"subresource":{"description":"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.","type":"string"},"time":{"description":"Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over.","$ref":"#/components/schemas/v1.Time"}}},"v1.FieldsV1":{"description":"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff"},"v1.OwnerReference":{"description":"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.","required":["apiVersion","kind","name","uid"],"properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"blockOwnerDeletion":{"description":"If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.","type":"boolean"},"controller":{"description":"If true, this reference points to the managing controller.","type":"boolean"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"uid":{"description":"UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1alpha1.CronWorkflowSpec":{"required":["workflowSpec","schedule"],"properties":{"concurrencyPolicy":{"type":"string"},"failedJobsHistoryLimit":{"type":"integer","format":"int32"},"schedule":{"type":"string"},"startingDeadlineSeconds":{"type":"integer","format":"int64"},"successfulJobsHistoryLimit":{"type":"integer","format":"int32"},"suspend":{"type":"boolean"},"timezone":{"type":"string"},"workflowMetadata":{"$ref":"#/components/schemas/v1.ObjectMeta"},"workflowSpec":{"$ref":"#/components/schemas/v1alpha1.WorkflowSpec"}}},"v1alpha1.WorkflowSpec":{"properties":{"activeDeadlineSeconds":{"type":"integer","format":"int64"},"affinity":{"$ref":"#/components/schemas/v1.Affinity"},"archiveLogs":{"type":"boolean"},"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.WorkflowLevelArtifactGC"},"artifactRepositoryRef":{"$ref":"#/components/schemas/v1alpha1.ArtifactRepositoryRef"},"automountServiceAccountToken":{"type":"boolean"},"dnsConfig":{"$ref":"#/components/schemas/v1.PodDNSConfig"},"dnsPolicy":{"type":"string"},"entrypoint":{"type":"string"},"executor":{"$ref":"#/components/schemas/v1alpha1.ExecutorConfig"},"hooks":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LifecycleHook"}},"hostAliases":{"type":"array","items":{"$ref":"#/components/schemas/v1.HostAlias"}},"hostNetwork":{"type":"boolean"},"imagePullSecrets":{"type":"array","items":{"$ref":"#/components/schemas/v1.LocalObjectReference"}},"metrics":{"$ref":"#/components/schemas/v1alpha1.Metrics"},"nodeSelector":{"type":"object","additionalProperties":{"type":"string"}},"onExit":{"type":"string"},"parallelism":{"type":"integer","format":"int64"},"podDisruptionBudget":{"$ref":"#/components/schemas/v1.PodDisruptionBudgetSpec"},"podGC":{"$ref":"#/components/schemas/v1alpha1.PodGC"},"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"podPriority":{"type":"integer","format":"int32"},"podPriorityClassName":{"type":"string"},"podSpecPatch":{"type":"string"},"priority":{"type":"integer","format":"int32"},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.RetryStrategy"},"schedulerName":{"type":"string"},"securityContext":{"$ref":"#/components/schemas/v1.PodSecurityContext"},"serviceAccountName":{"type":"string"},"shutdown":{"type":"string"},"suspend":{"type":"boolean"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.Synchronization"},"templateDefaults":{"$ref":"#/components/schemas/v1alpha1.Template"},"templates":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Template"}},"tolerations":{"type":"array","items":{"$ref":"#/components/schemas/v1.Toleration"}},"ttlStrategy":{"$ref":"#/components/schemas/v1alpha1.TTLStrategy"},"volumeClaimGC":{"$ref":"#/components/schemas/v1alpha1.VolumeClaimGC"},"volumeClaimTemplates":{"type":"array","items":{"$ref":"#/components/schemas/v1.PersistentVolumeClaim"}},"volumes":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}},"workflowMetadata":{"$ref":"#/components/schemas/v1alpha1.WorkflowMetadata"},"workflowTemplateRef":{"$ref":"#/components/schemas/v1alpha1.WorkflowTemplateRef"}}},"v1.Affinity":{"description":"Affinity is a group of affinity scheduling rules.","properties":{"nodeAffinity":{"description":"Describes node affinity scheduling rules for the pod.","$ref":"#/components/schemas/v1.NodeAffinity"},"podAffinity":{"description":"Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAffinity"},"podAntiAffinity":{"description":"Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAntiAffinity"}}},"v1.NodeAffinity":{"description":"Node affinity is a group of node affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.PreferredSchedulingTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.","$ref":"#/components/schemas/v1.NodeSelector"}}},"v1.PreferredSchedulingTerm":{"description":"An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).","required":["weight","preference"],"properties":{"preference":{"description":"A node selector term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.NodeSelectorTerm"},"weight":{"description":"Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.NodeSelectorTerm":{"description":"A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.","properties":{"matchExpressions":{"description":"A list of node selector requirements by node's labels.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}},"matchFields":{"description":"A list of node selector requirements by node's fields.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}}}},"v1.NodeSelectorRequirement":{"description":"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"The label key that the selector applies to.","type":"string"},"operator":{"description":"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.","type":"string"},"values":{"description":"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.NodeSelector":{"description":"A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.","required":["nodeSelectorTerms"],"properties":{"nodeSelectorTerms":{"description":"Required. A list of node selector terms. The terms are ORed.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorTerm"}}}},"v1.PodAffinity":{"description":"Pod affinity is a group of inter pod affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1.WeightedPodAffinityTerm":{"description":"The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)","required":["weight","podAffinityTerm"],"properties":{"podAffinityTerm":{"description":"Required. A pod affinity term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.PodAffinityTerm"},"weight":{"description":"weight associated with matching the corresponding podAffinityTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.PodAffinityTerm":{"description":"Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running","required":["topologyKey"],"properties":{"labelSelector":{"description":"A label query over a set of resources, in this case pods.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaceSelector":{"description":"A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means \"this pod's namespace\". An empty selector ({}) matches all namespaces.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaces":{"description":"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".","type":"array","items":{"type":"string"}},"topologyKey":{"description":"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.","type":"string"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.PodAntiAffinity":{"description":"Pod anti affinity is a group of inter pod anti affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1alpha1.Arguments":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Artifact":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.Parameter":{"required":["name"],"properties":{"default":{"type":"string"},"description":{"type":"string"},"enum":{"type":"array","items":{"type":"string"}},"globalName":{"type":"string"},"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.ValueFrom"}}},"v1alpha1.ValueFrom":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"default":{"type":"string"},"event":{"type":"string"},"expression":{"type":"string"},"jqFilter":{"type":"string"},"jsonPath":{"type":"string"},"parameter":{"type":"string"},"path":{"type":"string"},"supplied":{"$ref":"#/components/schemas/v1alpha1.SuppliedValueFrom"}}},"v1alpha1.SuppliedValueFrom":{},"v1alpha1.WorkflowLevelArtifactGC":{"properties":{"forceFinalizerRemoval":{"type":"boolean"},"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"podSpecPatch":{"type":"string"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.ArtifactRepositoryRef":{"properties":{"configMap":{"type":"string"},"key":{"type":"string"}}},"v1.PodDNSConfig":{"description":"PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy.","properties":{"nameservers":{"description":"A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed.","type":"array","items":{"type":"string"}},"options":{"description":"A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy.","type":"array","items":{"$ref":"#/components/schemas/v1.PodDNSConfigOption"}},"searches":{"description":"A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed.","type":"array","items":{"type":"string"}}}},"v1.PodDNSConfigOption":{"description":"PodDNSConfigOption defines DNS resolver options of a pod.","properties":{"name":{"description":"Required.","type":"string"},"value":{"type":"string"}}},"v1alpha1.ExecutorConfig":{"properties":{"serviceAccountName":{"type":"string"}}},"v1alpha1.LifecycleHook":{"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"expression":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"}}},"v1alpha1.TemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"},"template":{"type":"string"}}},"v1.HostAlias":{"description":"HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.","properties":{"hostnames":{"description":"Hostnames for the above IP address.","type":"array","items":{"type":"string"}},"ip":{"description":"IP address of the host file entry.","type":"string"}}},"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}},"v1alpha1.Metrics":{"required":["prometheus"],"properties":{"prometheus":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Prometheus"}}}},"v1alpha1.Prometheus":{"required":["name","help"],"properties":{"counter":{"$ref":"#/components/schemas/v1alpha1.Counter"},"gauge":{"$ref":"#/components/schemas/v1alpha1.Gauge"},"help":{"type":"string"},"histogram":{"$ref":"#/components/schemas/v1alpha1.Histogram"},"labels":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MetricLabel"}},"name":{"type":"string"},"when":{"type":"string"}}},"v1alpha1.Counter":{"required":["value"],"properties":{"value":{"type":"string"}}},"v1alpha1.Gauge":{"required":["value","realtime"],"properties":{"operation":{"type":"string"},"realtime":{"type":"boolean"},"value":{"type":"string"}}},"v1alpha1.Histogram":{"required":["value","buckets"],"properties":{"buckets":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Amount"}},"value":{"type":"string"}}},"v1alpha1.Amount":{},"v1alpha1.MetricLabel":{"required":["key","value"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1.PodDisruptionBudgetSpec":{"description":"PodDisruptionBudgetSpec is a description of a PodDisruptionBudget.","properties":{"maxUnavailable":{"description":"An eviction is allowed if at most \"maxUnavailable\" pods selected by \"selector\" are unavailable after the eviction, i.e. even in absence of the evicted pod. For example, one can prevent all voluntary evictions by specifying 0. This is a mutually exclusive setting with \"minAvailable\".","$ref":"#/components/schemas/intstr.IntOrString"},"minAvailable":{"description":"An eviction is allowed if at least \"minAvailable\" pods selected by \"selector\" will still be available after the eviction, i.e. even in the absence of the evicted pod. So for example you can prevent all voluntary evictions by specifying \"100%\".","$ref":"#/components/schemas/intstr.IntOrString"},"selector":{"description":"Label query over pods whose evictions are managed by the disruption budget. A null selector will match no pods, while an empty ({}) selector will select all pods within the namespace.","$ref":"#/components/schemas/v1.LabelSelector"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}},"v1alpha1.PodGC":{"properties":{"deleteDelayDuration":{"type":"string"},"labelSelector":{"$ref":"#/components/schemas/v1.LabelSelector"},"strategy":{"type":"string"}}},"v1alpha1.RetryStrategy":{"properties":{"affinity":{"$ref":"#/components/schemas/v1alpha1.RetryAffinity"},"backoff":{"$ref":"#/components/schemas/v1alpha1.Backoff"},"expression":{"type":"string"},"limit":{"$ref":"#/components/schemas/intstr.IntOrString"},"retryPolicy":{"type":"string"}}},"v1alpha1.RetryAffinity":{"properties":{"nodeAntiAffinity":{"$ref":"#/components/schemas/v1alpha1.RetryNodeAntiAffinity"}}},"v1alpha1.RetryNodeAntiAffinity":{},"v1alpha1.Backoff":{"properties":{"duration":{"type":"string"},"factor":{"$ref":"#/components/schemas/intstr.IntOrString"},"maxDuration":{"type":"string"}}},"v1.PodSecurityContext":{"description":"PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.","properties":{"fsGroup":{"description":"A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\n\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw ","type":"integer","format":"int64"},"fsGroupChangePolicy":{"description":"fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \"OnRootMismatch\" and \"Always\". If not specified, \"Always\" is used. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"supplementalGroups":{"description":"A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"type":"integer","format":"int64"}},"sysctls":{"description":"Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"$ref":"#/components/schemas/v1.Sysctl"}},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.SELinuxOptions":{"description":"SELinuxOptions are the labels to be applied to the container","properties":{"level":{"description":"Level is SELinux level label that applies to the container.","type":"string"},"role":{"description":"Role is a SELinux role label that applies to the container.","type":"string"},"type":{"description":"Type is a SELinux type label that applies to the container.","type":"string"},"user":{"description":"User is a SELinux user label that applies to the container.","type":"string"}}},"v1.SeccompProfile":{"description":"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.","required":["type"],"properties":{"localhostProfile":{"description":"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is \"Localhost\".","type":"string"},"type":{"description":"type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.","type":"string"}}},"v1.Sysctl":{"description":"Sysctl defines a kernel parameter to be set","required":["name","value"],"properties":{"name":{"description":"Name of a property to set","type":"string"},"value":{"description":"Value of a property to set","type":"string"}}},"v1.WindowsSecurityContextOptions":{"description":"WindowsSecurityContextOptions contain Windows-specific options and credentials.","properties":{"gmsaCredentialSpec":{"description":"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.","type":"string"},"gmsaCredentialSpecName":{"description":"GMSACredentialSpecName is the name of the GMSA credential spec to use.","type":"string"},"hostProcess":{"description":"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.","type":"boolean"},"runAsUserName":{"description":"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"string"}}},"v1alpha1.Synchronization":{"properties":{"mutex":{"$ref":"#/components/schemas/v1alpha1.Mutex"},"semaphore":{"$ref":"#/components/schemas/v1alpha1.SemaphoreRef"}}},"v1alpha1.Mutex":{"properties":{"name":{"type":"string"},"namespace":{"type":"string"}}},"v1alpha1.SemaphoreRef":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"namespace":{"type":"string"}}},"v1alpha1.Template":{"properties":{"activeDeadlineSeconds":{"$ref":"#/components/schemas/intstr.IntOrString"},"affinity":{"$ref":"#/components/schemas/v1.Affinity"},"archiveLocation":{"$ref":"#/components/schemas/v1alpha1.ArtifactLocation"},"automountServiceAccountToken":{"type":"boolean"},"container":{"$ref":"#/components/schemas/v1.Container"},"containerSet":{"$ref":"#/components/schemas/v1alpha1.ContainerSetTemplate"},"daemon":{"type":"boolean"},"dag":{"$ref":"#/components/schemas/v1alpha1.DAGTemplate"},"data":{"$ref":"#/components/schemas/v1alpha1.Data"},"executor":{"$ref":"#/components/schemas/v1alpha1.ExecutorConfig"},"failFast":{"type":"boolean"},"hostAliases":{"type":"array","items":{"$ref":"#/components/schemas/v1.HostAlias"}},"http":{"$ref":"#/components/schemas/v1alpha1.HTTP"},"initContainers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"inputs":{"$ref":"#/components/schemas/v1alpha1.Inputs"},"memoize":{"$ref":"#/components/schemas/v1alpha1.Memoize"},"metadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"metrics":{"$ref":"#/components/schemas/v1alpha1.Metrics"},"name":{"type":"string"},"nodeSelector":{"type":"object","additionalProperties":{"type":"string"}},"outputs":{"$ref":"#/components/schemas/v1alpha1.Outputs"},"parallelism":{"type":"integer","format":"int64"},"plugin":{"$ref":"#/components/schemas/v1alpha1.Plugin"},"podSpecPatch":{"type":"string"},"priority":{"type":"integer","format":"int32"},"priorityClassName":{"type":"string"},"resource":{"$ref":"#/components/schemas/v1alpha1.ResourceTemplate"},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.RetryStrategy"},"schedulerName":{"type":"string"},"script":{"$ref":"#/components/schemas/v1alpha1.ScriptTemplate"},"securityContext":{"$ref":"#/components/schemas/v1.PodSecurityContext"},"serviceAccountName":{"type":"string"},"sidecars":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"steps":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ParallelSteps"}},"suspend":{"$ref":"#/components/schemas/v1alpha1.SuspendTemplate"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.Synchronization"},"timeout":{"type":"string"},"tolerations":{"type":"array","items":{"$ref":"#/components/schemas/v1.Toleration"}},"volumes":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}}}},"v1alpha1.ArtifactLocation":{"properties":{"archiveLogs":{"type":"boolean"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"}}},"v1.Container":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1.EnvVar":{"description":"EnvVar represents an environment variable present in a Container.","required":["name"],"properties":{"name":{"description":"Name of the environment variable. Must be a C_IDENTIFIER.","type":"string"},"value":{"description":"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".","type":"string"},"valueFrom":{"description":"Source for the environment variable's value. Cannot be used if value is not empty.","$ref":"#/components/schemas/v1.EnvVarSource"}}},"v1.EnvVarSource":{"description":"EnvVarSource represents a source for the value of an EnvVar.","properties":{"configMapKeyRef":{"description":"Selects a key of a ConfigMap.","$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"fieldRef":{"description":"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"},"secretKeyRef":{"description":"Selects a key of a secret in the pod's namespace","$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.EnvFromSource":{"description":"EnvFromSource represents the source of a set of ConfigMaps","properties":{"configMapRef":{"description":"The ConfigMap to select from","$ref":"#/components/schemas/v1.ConfigMapEnvSource"},"prefix":{"description":"An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.","type":"string"},"secretRef":{"description":"The Secret to select from","$ref":"#/components/schemas/v1.SecretEnvSource"}}},"v1.ConfigMapEnvSource":{"description":"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap must be defined","type":"boolean"}}},"v1.SecretEnvSource":{"description":"SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret must be defined","type":"boolean"}}},"v1.Lifecycle":{"description":"Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.","properties":{"postStart":{"description":"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"},"preStop":{"description":"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"}}},"v1.LifecycleHandler":{"description":"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"tcpSocket":{"description":"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.","$ref":"#/components/schemas/v1.TCPSocketAction"}}},"v1.ExecAction":{"description":"ExecAction describes a \"run in container\" action.","properties":{"command":{"description":"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.","type":"array","items":{"type":"string"}}}},"v1.HTTPGetAction":{"description":"HTTPGetAction describes an action based on HTTP Get requests.","required":["port"],"properties":{"host":{"description":"Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.","type":"string"},"httpHeaders":{"description":"Custom headers to set in the request. HTTP allows repeated headers.","type":"array","items":{"$ref":"#/components/schemas/v1.HTTPHeader"}},"path":{"description":"Path to access on the HTTP server.","type":"string"},"port":{"description":"Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"},"scheme":{"description":"Scheme to use for connecting to the host. Defaults to HTTP.","type":"string"}}},"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}},"v1.TCPSocketAction":{"description":"TCPSocketAction describes an action based on opening a socket","required":["port"],"properties":{"host":{"description":"Optional: Host name to connect to, defaults to the pod IP.","type":"string"},"port":{"description":"Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"}}},"v1.Probe":{"description":"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"failureThreshold":{"description":"Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.","type":"integer","format":"int32"},"grpc":{"description":"GRPC specifies an action involving a GRPC port. This is a beta field and requires enabling GRPCContainerProbe feature gate.","$ref":"#/components/schemas/v1.GRPCAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"initialDelaySeconds":{"description":"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"},"periodSeconds":{"description":"How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.","type":"integer","format":"int32"},"successThreshold":{"description":"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.","type":"integer","format":"int32"},"tcpSocket":{"description":"TCPSocket specifies an action involving a TCP port.","$ref":"#/components/schemas/v1.TCPSocketAction"},"terminationGracePeriodSeconds":{"description":"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.","type":"integer","format":"int64"},"timeoutSeconds":{"description":"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"}}},"v1.GRPCAction":{"required":["port","service"],"properties":{"port":{"description":"Port number of the gRPC service. Number must be in the range 1 to 65535.","type":"integer","format":"int32"},"service":{"description":"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.","type":"string"}}},"v1.ContainerPort":{"description":"ContainerPort represents a network port in a single container.","required":["containerPort"],"properties":{"containerPort":{"description":"Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.","type":"integer","format":"int32"},"hostIP":{"description":"What host IP to bind the external port to.","type":"string"},"hostPort":{"description":"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.","type":"integer","format":"int32"},"name":{"description":"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.","type":"string"},"protocol":{"description":"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"v1.SecurityContext":{"description":"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.","properties":{"allowPrivilegeEscalation":{"description":"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"capabilities":{"description":"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.Capabilities"},"privileged":{"description":"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"procMount":{"description":"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"readOnlyRootFilesystem":{"description":"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Capabilities":{"description":"Adds and removes POSIX capabilities from running containers.","properties":{"add":{"description":"Added capabilities","type":"array","items":{"type":"string"}},"drop":{"description":"Removed capabilities","type":"array","items":{"type":"string"}}}},"v1.VolumeDevice":{"description":"volumeDevice describes a mapping of a raw block device within a container.","required":["name","devicePath"],"properties":{"devicePath":{"description":"devicePath is the path inside of the container that the device will be mapped to.","type":"string"},"name":{"description":"name must match the name of a persistentVolumeClaim in the pod","type":"string"}}},"v1.VolumeMount":{"description":"VolumeMount describes a mounting of a Volume within a container.","required":["name","mountPath"],"properties":{"mountPath":{"description":"Path within the container at which the volume should be mounted. Must not contain ':'.","type":"string"},"mountPropagation":{"description":"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10.","type":"string"},"name":{"description":"This must match the Name of a Volume.","type":"string"},"readOnly":{"description":"Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.","type":"boolean"},"subPath":{"description":"Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).","type":"string"},"subPathExpr":{"description":"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.","type":"string"}}},"v1alpha1.ContainerSetTemplate":{"required":["containers"],"properties":{"containers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ContainerNode"}},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.ContainerSetRetryStrategy"},"volumeMounts":{"type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}}}},"v1alpha1.ContainerNode":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"dependencies":{"type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.ContainerSetRetryStrategy":{"required":["retries"],"properties":{"duration":{"type":"string"},"retries":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"v1alpha1.DAGTemplate":{"required":["tasks"],"properties":{"failFast":{"type":"boolean"},"target":{"type":"string"},"tasks":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.DAGTask"}}}},"v1alpha1.DAGTask":{"required":["name"],"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"continueOn":{"$ref":"#/components/schemas/v1alpha1.ContinueOn"},"dependencies":{"type":"array","items":{"type":"string"}},"depends":{"type":"string"},"hooks":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LifecycleHook"}},"inline":{"$ref":"#/components/schemas/v1alpha1.Template"},"name":{"type":"string"},"onExit":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"},"when":{"type":"string"},"withItems":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Item"}},"withParam":{"type":"string"},"withSequence":{"$ref":"#/components/schemas/v1alpha1.Sequence"}}},"v1alpha1.ContinueOn":{"properties":{"error":{"type":"boolean"},"failed":{"type":"boolean"}}},"v1alpha1.Item":{},"v1alpha1.Sequence":{"properties":{"count":{"$ref":"#/components/schemas/intstr.IntOrString"},"end":{"$ref":"#/components/schemas/intstr.IntOrString"},"format":{"type":"string"},"start":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"v1alpha1.Data":{"required":["source","transformation"],"properties":{"source":{"$ref":"#/components/schemas/v1alpha1.DataSource"},"transformation":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.TransformationStep"}}}},"v1alpha1.DataSource":{"properties":{"artifactPaths":{"$ref":"#/components/schemas/v1alpha1.ArtifactPaths"}}},"v1alpha1.ArtifactPaths":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.TransformationStep":{"required":["expression"],"properties":{"expression":{"type":"string"}}},"v1alpha1.HTTP":{"required":["url"],"properties":{"body":{"type":"string"},"bodyFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPBodySource"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.HTTPHeader"}},"insecureSkipVerify":{"type":"boolean"},"method":{"type":"string"},"successCondition":{"type":"string"},"timeoutSeconds":{"type":"integer","format":"int64"},"url":{"type":"string"}}},"v1alpha1.HTTPBodySource":{"properties":{"bytes":{"type":"string"}}},"v1alpha1.HTTPHeader":{"required":["name"],"properties":{"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPHeaderSource"}}},"v1alpha1.HTTPHeaderSource":{"properties":{"secretKeyRef":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.UserContainer":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"mirrorVolumeMounts":{"type":"boolean"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.Inputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Memoize":{"required":["key","cache","maxAge"],"properties":{"cache":{"$ref":"#/components/schemas/v1alpha1.Cache"},"key":{"type":"string"},"maxAge":{"type":"string"}}},"v1alpha1.Cache":{"required":["configMap"],"properties":{"configMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"}}},"v1alpha1.Outputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"exitCode":{"type":"string"},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}},"result":{"type":"string"}}},"v1alpha1.Plugin":{},"v1alpha1.ResourceTemplate":{"required":["action"],"properties":{"action":{"type":"string"},"failureCondition":{"type":"string"},"flags":{"type":"array","items":{"type":"string"}},"manifest":{"type":"string"},"manifestFrom":{"$ref":"#/components/schemas/v1alpha1.ManifestFrom"},"mergeStrategy":{"type":"string"},"setOwnerReference":{"type":"boolean"},"successCondition":{"type":"string"}}},"v1alpha1.ManifestFrom":{"required":["artifact"],"properties":{"artifact":{"$ref":"#/components/schemas/v1alpha1.Artifact"}}},"v1alpha1.ScriptTemplate":{"description":"A single application container that you want to run within a pod.","required":["name","source"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"source":{"type":"string"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.ParallelSteps":{},"v1alpha1.SuspendTemplate":{"properties":{"duration":{"type":"string"}}},"v1.Toleration":{"description":"The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .","properties":{"effect":{"description":"Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.","type":"string"},"key":{"description":"Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.","type":"string"},"operator":{"description":"Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.","type":"string"},"tolerationSeconds":{"description":"TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.","type":"integer","format":"int64"},"value":{"description":"Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.","type":"string"}}},"v1.Volume":{"description":"Volume represents a named volume in a pod that may be accessed by any container in the pod.","required":["name"],"properties":{"awsElasticBlockStore":{"description":"awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","$ref":"#/components/schemas/v1.AWSElasticBlockStoreVolumeSource"},"azureDisk":{"description":"azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureDiskVolumeSource"},"azureFile":{"description":"azureFile represents an Azure File Service mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureFileVolumeSource"},"cephfs":{"description":"cephFS represents a Ceph FS mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.CephFSVolumeSource"},"cinder":{"description":"cinder represents a cinder volume attached and mounted on kubelets host machine. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","$ref":"#/components/schemas/v1.CinderVolumeSource"},"configMap":{"description":"configMap represents a configMap that should populate this volume","$ref":"#/components/schemas/v1.ConfigMapVolumeSource"},"csi":{"description":"csi (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers (Beta feature).","$ref":"#/components/schemas/v1.CSIVolumeSource"},"downwardAPI":{"description":"downwardAPI represents downward API about the pod that should populate this volume","$ref":"#/components/schemas/v1.DownwardAPIVolumeSource"},"emptyDir":{"description":"emptyDir represents a temporary directory that shares a pod's lifetime. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","$ref":"#/components/schemas/v1.EmptyDirVolumeSource"},"ephemeral":{"description":"ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed.\n\nUse this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity\n tracking are needed,\nc) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through\n a PersistentVolumeClaim (see EphemeralVolumeSource for more\n information on the connection between this volume type\n and PersistentVolumeClaim).\n\nUse PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod.\n\nUse CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information.\n\nA pod can use both types of ephemeral volumes and persistent volumes at the same time.","$ref":"#/components/schemas/v1.EphemeralVolumeSource"},"fc":{"description":"fc represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.","$ref":"#/components/schemas/v1.FCVolumeSource"},"flexVolume":{"description":"flexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","$ref":"#/components/schemas/v1.FlexVolumeSource"},"flocker":{"description":"flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running","$ref":"#/components/schemas/v1.FlockerVolumeSource"},"gcePersistentDisk":{"description":"gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","$ref":"#/components/schemas/v1.GCEPersistentDiskVolumeSource"},"gitRepo":{"description":"gitRepo represents a git repository at a particular revision. DEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","$ref":"#/components/schemas/v1.GitRepoVolumeSource"},"glusterfs":{"description":"glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/glusterfs/README.md","$ref":"#/components/schemas/v1.GlusterfsVolumeSource"},"hostPath":{"description":"hostPath represents a pre-existing file or directory on the host machine that is directly exposed to the container. This is generally used for system agents or other privileged things that are allowed to see the host machine. Most containers will NOT need this. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","$ref":"#/components/schemas/v1.HostPathVolumeSource"},"iscsi":{"description":"iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://examples.k8s.io/volumes/iscsi/README.md","$ref":"#/components/schemas/v1.ISCSIVolumeSource"},"name":{"description":"name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"nfs":{"description":"nfs represents an NFS mount on the host that shares a pod's lifetime More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","$ref":"#/components/schemas/v1.NFSVolumeSource"},"persistentVolumeClaim":{"description":"persistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimVolumeSource"},"photonPersistentDisk":{"description":"photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PhotonPersistentDiskVolumeSource"},"portworxVolume":{"description":"portworxVolume represents a portworx volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PortworxVolumeSource"},"projected":{"description":"projected items for all in one resources secrets, configmaps, and downward API","$ref":"#/components/schemas/v1.ProjectedVolumeSource"},"quobyte":{"description":"quobyte represents a Quobyte mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.QuobyteVolumeSource"},"rbd":{"description":"rbd represents a Rados Block Device mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/rbd/README.md","$ref":"#/components/schemas/v1.RBDVolumeSource"},"scaleIO":{"description":"scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.ScaleIOVolumeSource"},"secret":{"description":"secret represents a secret that should populate this volume. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","$ref":"#/components/schemas/v1.SecretVolumeSource"},"storageos":{"description":"storageOS represents a StorageOS volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.StorageOSVolumeSource"},"vsphereVolume":{"description":"vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.VsphereVirtualDiskVolumeSource"}}},"v1.AWSElasticBlockStoreVolumeSource":{"description":"Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).","type":"integer","format":"int32"},"readOnly":{"description":"readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"boolean"},"volumeID":{"description":"volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"}}},"v1.AzureDiskVolumeSource":{"description":"AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","required":["diskName","diskURI"],"properties":{"cachingMode":{"description":"cachingMode is the Host Caching mode: None, Read Only, Read Write.","type":"string"},"diskName":{"description":"diskName is the Name of the data disk in the blob storage","type":"string"},"diskURI":{"description":"diskURI is the URI of data disk in the blob storage","type":"string"},"fsType":{"description":"fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"kind":{"description":"kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"}}},"v1.AzureFileVolumeSource":{"description":"AzureFile represents an Azure File Service mount on the host and bind mount to the pod.","required":["secretName","shareName"],"properties":{"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretName":{"description":"secretName is the name of secret that contains Azure Storage Account Name and Key","type":"string"},"shareName":{"description":"shareName is the azure share Name","type":"string"}}},"v1.CephFSVolumeSource":{"description":"Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.","required":["monitors"],"properties":{"monitors":{"description":"monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"path":{"description":"path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /","type":"string"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"boolean"},"secretFile":{"description":"secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"},"secretRef":{"description":"secretRef is Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"}}},"v1.CinderVolumeSource":{"description":"Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"boolean"},"secretRef":{"description":"secretRef is optional: points to a secret object containing parameters used to connect to OpenStack.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeID":{"description":"volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"}}},"v1.ConfigMapVolumeSource":{"description":"Adapts a ConfigMap into a volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.KeyToPath":{"description":"Maps a string key to a path within a volume.","required":["key","path"],"properties":{"key":{"description":"key is the key to project.","type":"string"},"mode":{"description":"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.","type":"string"}}},"v1.CSIVolumeSource":{"description":"Represents a source location of a volume to mount, managed by an external CSI driver","required":["driver"],"properties":{"driver":{"description":"driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.","type":"string"},"fsType":{"description":"fsType to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.","type":"string"},"nodePublishSecretRef":{"description":"nodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secret references are passed.","$ref":"#/components/schemas/v1.LocalObjectReference"},"readOnly":{"description":"readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).","type":"boolean"},"volumeAttributes":{"description":"volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.","type":"object","additionalProperties":{"type":"string"}}}},"v1.DownwardAPIVolumeSource":{"description":"DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"Items is a list of downward API volume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.DownwardAPIVolumeFile":{"description":"DownwardAPIVolumeFile represents information to create the file containing the pod field","required":["path"],"properties":{"fieldRef":{"description":"Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"mode":{"description":"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'","type":"string"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"}}},"v1.EmptyDirVolumeSource":{"description":"Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.","properties":{"medium":{"description":"medium represents what type of storage medium should back this directory. The default is \"\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","type":"string"},"sizeLimit":{"description":"sizeLimit is the total amount of local storage required for this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. The default is nil which means that the limit is undefined. More info: http://kubernetes.io/docs/user-guide/volumes#emptydir","$ref":"#/components/schemas/resource.Quantity"}}},"v1.EphemeralVolumeSource":{"description":"Represents an ephemeral volume that is handled by a normal storage driver.","properties":{"volumeClaimTemplate":{"description":"Will be used to create a stand-alone PVC to provision the volume. The pod in which this EphemeralVolumeSource is embedded will be the owner of the PVC, i.e. the PVC will be deleted together with the pod. The name of the PVC will be `-` where `` is the name from the `PodSpec.Volumes` array entry. Pod validation will reject the pod if the concatenated name is not valid for a PVC (for example, too long).\n\nAn existing PVC with that name that is not owned by the pod will *not* be used for the pod to avoid using an unrelated volume by mistake. Starting the pod is then blocked until the unrelated PVC is removed. If such a pre-created PVC is meant to be used by the pod, the PVC has to updated with an owner reference to the pod once the pod exists. Normally this should not be necessary, but it may be useful when manually reconstructing a broken cluster.\n\nThis field is read-only and no changes will be made by Kubernetes to the PVC after it has been created.\n\nRequired, must not be nil.","$ref":"#/components/schemas/v1.PersistentVolumeClaimTemplate"}}},"v1.PersistentVolumeClaimTemplate":{"description":"PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.","required":["spec"],"properties":{"metadata":{"description":"May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"The specification for the PersistentVolumeClaim. The entire content is copied unchanged into the PVC that gets created from this template. The same fields as in a PersistentVolumeClaim are also valid here.","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"}}},"v1.PersistentVolumeClaimSpec":{"description":"PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes","properties":{"accessModes":{"description":"accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"dataSource":{"description":"dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"dataSourceRef":{"description":"dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"resources":{"description":"resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources","$ref":"#/components/schemas/v1.ResourceRequirements"},"selector":{"description":"selector is a label query over volumes to consider for binding.","$ref":"#/components/schemas/v1.LabelSelector"},"storageClassName":{"description":"storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1","type":"string"},"volumeMode":{"description":"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.","type":"string"},"volumeName":{"description":"volumeName is the binding reference to the PersistentVolume backing this claim.","type":"string"}}},"v1.TypedLocalObjectReference":{"description":"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.","required":["apiGroup","kind","name"],"properties":{"apiGroup":{"description":"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.","type":"string"},"kind":{"description":"Kind is the type of resource being referenced","type":"string"},"name":{"description":"Name is the name of resource being referenced","type":"string"}}},"v1.FCVolumeSource":{"description":"Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"lun":{"description":"lun is Optional: FC target lun number","type":"integer","format":"int32"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"targetWWNs":{"description":"targetWWNs is Optional: FC target worldwide names (WWNs)","type":"array","items":{"type":"string"}},"wwids":{"description":"wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.","type":"array","items":{"type":"string"}}}},"v1.FlexVolumeSource":{"description":"FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","required":["driver"],"properties":{"driver":{"description":"driver is the name of the driver to use for this volume.","type":"string"},"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.","type":"string"},"options":{"description":"options is Optional: this field holds extra command options if any.","type":"object","additionalProperties":{"type":"string"}},"readOnly":{"description":"readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef is Optional: secretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts.","$ref":"#/components/schemas/v1.LocalObjectReference"}}},"v1.FlockerVolumeSource":{"description":"Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.","properties":{"datasetName":{"description":"datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated","type":"string"},"datasetUUID":{"description":"datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset","type":"string"}}},"v1.GCEPersistentDiskVolumeSource":{"description":"Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.","required":["pdName"],"properties":{"fsType":{"description":"fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"integer","format":"int32"},"pdName":{"description":"pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"boolean"}}},"v1.GitRepoVolumeSource":{"description":"Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","required":["repository"],"properties":{"directory":{"description":"directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.","type":"string"},"repository":{"description":"repository is the URL","type":"string"},"revision":{"description":"revision is the commit hash for the specified revision.","type":"string"}}},"v1.GlusterfsVolumeSource":{"description":"Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.","required":["endpoints","path"],"properties":{"endpoints":{"description":"endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"path":{"description":"path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"readOnly":{"description":"readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"boolean"}}},"v1.HostPathVolumeSource":{"description":"Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.","required":["path"],"properties":{"path":{"description":"path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"},"type":{"description":"type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"}}},"v1.ISCSIVolumeSource":{"description":"Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.","required":["targetPortal","iqn","lun"],"properties":{"chapAuthDiscovery":{"description":"chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication","type":"boolean"},"chapAuthSession":{"description":"chapAuthSession defines whether support iSCSI Session CHAP authentication","type":"boolean"},"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi","type":"string"},"initiatorName":{"description":"initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.","type":"string"},"iqn":{"description":"iqn is the target iSCSI Qualified Name.","type":"string"},"iscsiInterface":{"description":"iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).","type":"string"},"lun":{"description":"lun represents iSCSI Target Lun number.","type":"integer","format":"int32"},"portals":{"description":"portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"array","items":{"type":"string"}},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.","type":"boolean"},"secretRef":{"description":"secretRef is the CHAP Secret for iSCSI target and initiator authentication","$ref":"#/components/schemas/v1.LocalObjectReference"},"targetPortal":{"description":"targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"string"}}},"v1.NFSVolumeSource":{"description":"Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.","required":["server","path"],"properties":{"path":{"description":"path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"},"readOnly":{"description":"readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"boolean"},"server":{"description":"server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"}}},"v1.PersistentVolumeClaimVolumeSource":{"description":"PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).","required":["claimName"],"properties":{"claimName":{"description":"claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","type":"string"},"readOnly":{"description":"readOnly Will force the ReadOnly setting in VolumeMounts. Default false.","type":"boolean"}}},"v1.PhotonPersistentDiskVolumeSource":{"description":"Represents a Photon Controller persistent disk resource.","required":["pdID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"pdID":{"description":"pdID is the ID that identifies Photon Controller persistent disk","type":"string"}}},"v1.PortworxVolumeSource":{"description":"PortworxVolumeSource represents a Portworx volume resource.","required":["volumeID"],"properties":{"fsType":{"description":"fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"volumeID":{"description":"volumeID uniquely identifies a Portworx volume","type":"string"}}},"v1.ProjectedVolumeSource":{"description":"Represents a projected volume source","required":["sources"],"properties":{"defaultMode":{"description":"defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"sources":{"description":"sources is the list of volume projections","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeProjection"}}}},"v1.VolumeProjection":{"description":"Projection that may be projected along with other supported volume types","properties":{"configMap":{"description":"configMap information about the configMap data to project","$ref":"#/components/schemas/v1.ConfigMapProjection"},"downwardAPI":{"description":"downwardAPI information about the downwardAPI data to project","$ref":"#/components/schemas/v1.DownwardAPIProjection"},"secret":{"description":"secret information about the secret data to project","$ref":"#/components/schemas/v1.SecretProjection"},"serviceAccountToken":{"description":"serviceAccountToken is information about the serviceAccountToken data to project","$ref":"#/components/schemas/v1.ServiceAccountTokenProjection"}}},"v1.ConfigMapProjection":{"description":"Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.DownwardAPIProjection":{"description":"Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.","properties":{"items":{"description":"Items is a list of DownwardAPIVolume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.SecretProjection":{"description":"Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional field specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.ServiceAccountTokenProjection":{"description":"ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).","required":["path"],"properties":{"audience":{"description":"audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.","type":"string"},"expirationSeconds":{"description":"expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.","type":"integer","format":"int64"},"path":{"description":"path is the path relative to the mount point of the file to project the token into.","type":"string"}}},"v1.QuobyteVolumeSource":{"description":"Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.","required":["registry","volume"],"properties":{"group":{"description":"group to map volume access to Default is no group","type":"string"},"readOnly":{"description":"readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.","type":"boolean"},"registry":{"description":"registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes","type":"string"},"tenant":{"description":"tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin","type":"string"},"user":{"description":"user to map volume access to Defaults to serivceaccount user","type":"string"},"volume":{"description":"volume is a string that references an already created Quobyte volume by name.","type":"string"}}},"v1.RBDVolumeSource":{"description":"Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.","required":["monitors","image"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd","type":"string"},"image":{"description":"image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"keyring":{"description":"keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"monitors":{"description":"monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"pool":{"description":"pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"boolean"},"secretRef":{"description":"secretRef is name of the authentication secret for RBDUser. If provided overrides keyring. Default is nil. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"}}},"v1.ScaleIOVolumeSource":{"description":"ScaleIOVolumeSource represents a persistent ScaleIO volume","required":["gateway","system","secretRef"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\".","type":"string"},"gateway":{"description":"gateway is the host address of the ScaleIO API Gateway.","type":"string"},"protectionDomain":{"description":"protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef references to the secret for ScaleIO user and other sensitive information. If this is not provided, Login operation will fail.","$ref":"#/components/schemas/v1.LocalObjectReference"},"sslEnabled":{"description":"sslEnabled Flag enable/disable SSL communication with Gateway, default false","type":"boolean"},"storageMode":{"description":"storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.","type":"string"},"storagePool":{"description":"storagePool is the ScaleIO Storage Pool associated with the protection domain.","type":"string"},"system":{"description":"system is the name of the storage system as configured in ScaleIO.","type":"string"},"volumeName":{"description":"volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.","type":"string"}}},"v1.SecretVolumeSource":{"description":"Adapts a Secret into a volume.\n\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"optional":{"description":"optional field specify whether the Secret or its keys must be defined","type":"boolean"},"secretName":{"description":"secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","type":"string"}}},"v1.StorageOSVolumeSource":{"description":"Represents a StorageOS persistent volume resource.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeName":{"description":"volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.","type":"string"},"volumeNamespace":{"description":"volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.","type":"string"}}},"v1.VsphereVirtualDiskVolumeSource":{"description":"Represents a vSphere volume resource.","required":["volumePath"],"properties":{"fsType":{"description":"fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"storagePolicyID":{"description":"storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.","type":"string"},"storagePolicyName":{"description":"storagePolicyName is the storage Policy Based Management (SPBM) profile name.","type":"string"},"volumePath":{"description":"volumePath is the path that identifies vSphere volume vmdk","type":"string"}}},"v1alpha1.TTLStrategy":{"properties":{"secondsAfterCompletion":{"type":"integer","format":"int32"},"secondsAfterFailure":{"type":"integer","format":"int32"},"secondsAfterSuccess":{"type":"integer","format":"int32"}}},"v1alpha1.VolumeClaimGC":{"properties":{"strategy":{"type":"string"}}},"v1.PersistentVolumeClaim":{"description":"PersistentVolumeClaim is a user's request for and claim to a persistent volume","properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"description":"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"spec defines the desired characteristics of a volume requested by a pod author. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"},"status":{"description":"status represents the current information/status of a persistent volume claim. Read-only. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimStatus"}}},"v1.PersistentVolumeClaimStatus":{"description":"PersistentVolumeClaimStatus is the current status of a persistent volume claim.","properties":{"accessModes":{"description":"accessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"allocatedResources":{"description":"allocatedResources is the storage resource within AllocatedResources tracks the capacity allocated to a PVC. It may be larger than the actual capacity when a volume expansion operation is requested. For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. If a volume expansion capacity request is lowered, allocatedResources is only lowered if there are no expansion operations in progress and if the actual volume capacity is equal or lower than the requested capacity. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"capacity":{"description":"capacity represents the actual resources of the underlying volume.","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"conditions":{"description":"conditions is the current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'ResizeStarted'.","type":"array","items":{"$ref":"#/components/schemas/v1.PersistentVolumeClaimCondition"}},"phase":{"description":"phase represents the current phase of PersistentVolumeClaim.","type":"string"},"resizeStatus":{"description":"resizeStatus stores status of resize operation. ResizeStatus is not set by default but when expansion is complete resizeStatus is set to empty string by resize controller or kubelet. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.","type":"string"}}},"v1.PersistentVolumeClaimCondition":{"description":"PersistentVolumeClaimCondition contails details about state of pvc","required":["type","status"],"properties":{"lastProbeTime":{"description":"lastProbeTime is the time we probed the condition.","$ref":"#/components/schemas/v1.Time"},"lastTransitionTime":{"description":"lastTransitionTime is the time the condition transitioned from one status to another.","$ref":"#/components/schemas/v1.Time"},"message":{"description":"message is the human-readable message indicating details about last transition.","type":"string"},"reason":{"description":"reason is a unique, this should be a short, machine understandable string that gives the reason for condition's last transition. If it reports \"ResizeStarted\" that means the underlying persistent volume is being resized.","type":"string"},"status":{"type":"string"},"type":{"type":"string"}}},"v1alpha1.WorkflowMetadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}},"labelsFrom":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LabelValueFrom"}}}},"v1alpha1.LabelValueFrom":{"required":["expression"],"properties":{"expression":{"type":"string"}}},"v1alpha1.WorkflowTemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"}}},"v1alpha1.CronWorkflowStatus":{"required":["active","lastScheduledTime","conditions"],"properties":{"active":{"type":"array","items":{"$ref":"#/components/schemas/v1.ObjectReference"}},"conditions":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Condition"}},"lastScheduledTime":{"$ref":"#/components/schemas/v1.Time"}}},"v1.ObjectReference":{"description":"ObjectReference contains enough information to let you inspect or modify the referred object.","properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"fieldPath":{"description":"If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \"spec.containers{name}\" (where \"name\" refers to the name of the container that triggered the event) or if no container name is specified \"spec.containers[2]\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.","type":"string"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"namespace":{"description":"Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/","type":"string"},"resourceVersion":{"description":"Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency","type":"string"},"uid":{"description":"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids","type":"string"}}},"v1alpha1.Condition":{"properties":{"message":{"type":"string"},"status":{"type":"string"},"type":{"type":"string"}}}}}} ``` ## The v1alpha1.CronWorkflowSpec object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.CronWorkflowSpec":{"required":["workflowSpec","schedule"],"properties":{"concurrencyPolicy":{"type":"string"},"failedJobsHistoryLimit":{"type":"integer","format":"int32"},"schedule":{"type":"string"},"startingDeadlineSeconds":{"type":"integer","format":"int64"},"successfulJobsHistoryLimit":{"type":"integer","format":"int32"},"suspend":{"type":"boolean"},"timezone":{"type":"string"},"workflowMetadata":{"$ref":"#/components/schemas/v1.ObjectMeta"},"workflowSpec":{"$ref":"#/components/schemas/v1alpha1.WorkflowSpec"}}},"v1.ObjectMeta":{"description":"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.","properties":{"annotations":{"description":"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations","type":"object","additionalProperties":{"type":"string"}},"clusterName":{"description":"Deprecated: ClusterName is a legacy field that was always cleared by the system and never used; it will be removed completely in 1.25.\n\nThe name in the go struct is changed to help clients detect accidental use.","type":"string"},"creationTimestamp":{"description":"CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"deletionGracePeriodSeconds":{"description":"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.","type":"integer","format":"int64"},"deletionTimestamp":{"description":"DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"finalizers":{"description":"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.","type":"array","items":{"type":"string"}},"generateName":{"description":"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency","type":"string"},"generation":{"description":"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.","type":"integer","format":"int64"},"labels":{"description":"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels","type":"object","additionalProperties":{"type":"string"}},"managedFields":{"description":"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.","type":"array","items":{"$ref":"#/components/schemas/v1.ManagedFieldsEntry"}},"name":{"description":"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"namespace":{"description":"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces","type":"string"},"ownerReferences":{"description":"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.","type":"array","items":{"$ref":"#/components/schemas/v1.OwnerReference"}},"resourceVersion":{"description":"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency","type":"string"},"selfLink":{"description":"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.","type":"string"},"uid":{"description":"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}},"v1.ManagedFieldsEntry":{"description":"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.","properties":{"apiVersion":{"description":"APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.","type":"string"},"fieldsType":{"description":"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"","type":"string"},"fieldsV1":{"description":"FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type.","$ref":"#/components/schemas/v1.FieldsV1"},"manager":{"description":"Manager is an identifier of the workflow managing these fields.","type":"string"},"operation":{"description":"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.","type":"string"},"subresource":{"description":"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.","type":"string"},"time":{"description":"Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over.","$ref":"#/components/schemas/v1.Time"}}},"v1.FieldsV1":{"description":"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff"},"v1.OwnerReference":{"description":"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.","required":["apiVersion","kind","name","uid"],"properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"blockOwnerDeletion":{"description":"If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.","type":"boolean"},"controller":{"description":"If true, this reference points to the managing controller.","type":"boolean"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"uid":{"description":"UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1alpha1.WorkflowSpec":{"properties":{"activeDeadlineSeconds":{"type":"integer","format":"int64"},"affinity":{"$ref":"#/components/schemas/v1.Affinity"},"archiveLogs":{"type":"boolean"},"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.WorkflowLevelArtifactGC"},"artifactRepositoryRef":{"$ref":"#/components/schemas/v1alpha1.ArtifactRepositoryRef"},"automountServiceAccountToken":{"type":"boolean"},"dnsConfig":{"$ref":"#/components/schemas/v1.PodDNSConfig"},"dnsPolicy":{"type":"string"},"entrypoint":{"type":"string"},"executor":{"$ref":"#/components/schemas/v1alpha1.ExecutorConfig"},"hooks":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LifecycleHook"}},"hostAliases":{"type":"array","items":{"$ref":"#/components/schemas/v1.HostAlias"}},"hostNetwork":{"type":"boolean"},"imagePullSecrets":{"type":"array","items":{"$ref":"#/components/schemas/v1.LocalObjectReference"}},"metrics":{"$ref":"#/components/schemas/v1alpha1.Metrics"},"nodeSelector":{"type":"object","additionalProperties":{"type":"string"}},"onExit":{"type":"string"},"parallelism":{"type":"integer","format":"int64"},"podDisruptionBudget":{"$ref":"#/components/schemas/v1.PodDisruptionBudgetSpec"},"podGC":{"$ref":"#/components/schemas/v1alpha1.PodGC"},"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"podPriority":{"type":"integer","format":"int32"},"podPriorityClassName":{"type":"string"},"podSpecPatch":{"type":"string"},"priority":{"type":"integer","format":"int32"},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.RetryStrategy"},"schedulerName":{"type":"string"},"securityContext":{"$ref":"#/components/schemas/v1.PodSecurityContext"},"serviceAccountName":{"type":"string"},"shutdown":{"type":"string"},"suspend":{"type":"boolean"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.Synchronization"},"templateDefaults":{"$ref":"#/components/schemas/v1alpha1.Template"},"templates":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Template"}},"tolerations":{"type":"array","items":{"$ref":"#/components/schemas/v1.Toleration"}},"ttlStrategy":{"$ref":"#/components/schemas/v1alpha1.TTLStrategy"},"volumeClaimGC":{"$ref":"#/components/schemas/v1alpha1.VolumeClaimGC"},"volumeClaimTemplates":{"type":"array","items":{"$ref":"#/components/schemas/v1.PersistentVolumeClaim"}},"volumes":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}},"workflowMetadata":{"$ref":"#/components/schemas/v1alpha1.WorkflowMetadata"},"workflowTemplateRef":{"$ref":"#/components/schemas/v1alpha1.WorkflowTemplateRef"}}},"v1.Affinity":{"description":"Affinity is a group of affinity scheduling rules.","properties":{"nodeAffinity":{"description":"Describes node affinity scheduling rules for the pod.","$ref":"#/components/schemas/v1.NodeAffinity"},"podAffinity":{"description":"Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAffinity"},"podAntiAffinity":{"description":"Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAntiAffinity"}}},"v1.NodeAffinity":{"description":"Node affinity is a group of node affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.PreferredSchedulingTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.","$ref":"#/components/schemas/v1.NodeSelector"}}},"v1.PreferredSchedulingTerm":{"description":"An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).","required":["weight","preference"],"properties":{"preference":{"description":"A node selector term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.NodeSelectorTerm"},"weight":{"description":"Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.NodeSelectorTerm":{"description":"A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.","properties":{"matchExpressions":{"description":"A list of node selector requirements by node's labels.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}},"matchFields":{"description":"A list of node selector requirements by node's fields.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}}}},"v1.NodeSelectorRequirement":{"description":"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"The label key that the selector applies to.","type":"string"},"operator":{"description":"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.","type":"string"},"values":{"description":"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.NodeSelector":{"description":"A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.","required":["nodeSelectorTerms"],"properties":{"nodeSelectorTerms":{"description":"Required. A list of node selector terms. The terms are ORed.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorTerm"}}}},"v1.PodAffinity":{"description":"Pod affinity is a group of inter pod affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1.WeightedPodAffinityTerm":{"description":"The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)","required":["weight","podAffinityTerm"],"properties":{"podAffinityTerm":{"description":"Required. A pod affinity term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.PodAffinityTerm"},"weight":{"description":"weight associated with matching the corresponding podAffinityTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.PodAffinityTerm":{"description":"Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running","required":["topologyKey"],"properties":{"labelSelector":{"description":"A label query over a set of resources, in this case pods.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaceSelector":{"description":"A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means \"this pod's namespace\". An empty selector ({}) matches all namespaces.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaces":{"description":"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".","type":"array","items":{"type":"string"}},"topologyKey":{"description":"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.","type":"string"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.PodAntiAffinity":{"description":"Pod anti affinity is a group of inter pod anti affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1alpha1.Arguments":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Artifact":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.Parameter":{"required":["name"],"properties":{"default":{"type":"string"},"description":{"type":"string"},"enum":{"type":"array","items":{"type":"string"}},"globalName":{"type":"string"},"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.ValueFrom"}}},"v1alpha1.ValueFrom":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"default":{"type":"string"},"event":{"type":"string"},"expression":{"type":"string"},"jqFilter":{"type":"string"},"jsonPath":{"type":"string"},"parameter":{"type":"string"},"path":{"type":"string"},"supplied":{"$ref":"#/components/schemas/v1alpha1.SuppliedValueFrom"}}},"v1alpha1.SuppliedValueFrom":{},"v1alpha1.WorkflowLevelArtifactGC":{"properties":{"forceFinalizerRemoval":{"type":"boolean"},"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"podSpecPatch":{"type":"string"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.ArtifactRepositoryRef":{"properties":{"configMap":{"type":"string"},"key":{"type":"string"}}},"v1.PodDNSConfig":{"description":"PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy.","properties":{"nameservers":{"description":"A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed.","type":"array","items":{"type":"string"}},"options":{"description":"A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy.","type":"array","items":{"$ref":"#/components/schemas/v1.PodDNSConfigOption"}},"searches":{"description":"A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed.","type":"array","items":{"type":"string"}}}},"v1.PodDNSConfigOption":{"description":"PodDNSConfigOption defines DNS resolver options of a pod.","properties":{"name":{"description":"Required.","type":"string"},"value":{"type":"string"}}},"v1alpha1.ExecutorConfig":{"properties":{"serviceAccountName":{"type":"string"}}},"v1alpha1.LifecycleHook":{"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"expression":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"}}},"v1alpha1.TemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"},"template":{"type":"string"}}},"v1.HostAlias":{"description":"HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.","properties":{"hostnames":{"description":"Hostnames for the above IP address.","type":"array","items":{"type":"string"}},"ip":{"description":"IP address of the host file entry.","type":"string"}}},"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}},"v1alpha1.Metrics":{"required":["prometheus"],"properties":{"prometheus":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Prometheus"}}}},"v1alpha1.Prometheus":{"required":["name","help"],"properties":{"counter":{"$ref":"#/components/schemas/v1alpha1.Counter"},"gauge":{"$ref":"#/components/schemas/v1alpha1.Gauge"},"help":{"type":"string"},"histogram":{"$ref":"#/components/schemas/v1alpha1.Histogram"},"labels":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MetricLabel"}},"name":{"type":"string"},"when":{"type":"string"}}},"v1alpha1.Counter":{"required":["value"],"properties":{"value":{"type":"string"}}},"v1alpha1.Gauge":{"required":["value","realtime"],"properties":{"operation":{"type":"string"},"realtime":{"type":"boolean"},"value":{"type":"string"}}},"v1alpha1.Histogram":{"required":["value","buckets"],"properties":{"buckets":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Amount"}},"value":{"type":"string"}}},"v1alpha1.Amount":{},"v1alpha1.MetricLabel":{"required":["key","value"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1.PodDisruptionBudgetSpec":{"description":"PodDisruptionBudgetSpec is a description of a PodDisruptionBudget.","properties":{"maxUnavailable":{"description":"An eviction is allowed if at most \"maxUnavailable\" pods selected by \"selector\" are unavailable after the eviction, i.e. even in absence of the evicted pod. For example, one can prevent all voluntary evictions by specifying 0. This is a mutually exclusive setting with \"minAvailable\".","$ref":"#/components/schemas/intstr.IntOrString"},"minAvailable":{"description":"An eviction is allowed if at least \"minAvailable\" pods selected by \"selector\" will still be available after the eviction, i.e. even in the absence of the evicted pod. So for example you can prevent all voluntary evictions by specifying \"100%\".","$ref":"#/components/schemas/intstr.IntOrString"},"selector":{"description":"Label query over pods whose evictions are managed by the disruption budget. A null selector will match no pods, while an empty ({}) selector will select all pods within the namespace.","$ref":"#/components/schemas/v1.LabelSelector"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}},"v1alpha1.PodGC":{"properties":{"deleteDelayDuration":{"type":"string"},"labelSelector":{"$ref":"#/components/schemas/v1.LabelSelector"},"strategy":{"type":"string"}}},"v1alpha1.RetryStrategy":{"properties":{"affinity":{"$ref":"#/components/schemas/v1alpha1.RetryAffinity"},"backoff":{"$ref":"#/components/schemas/v1alpha1.Backoff"},"expression":{"type":"string"},"limit":{"$ref":"#/components/schemas/intstr.IntOrString"},"retryPolicy":{"type":"string"}}},"v1alpha1.RetryAffinity":{"properties":{"nodeAntiAffinity":{"$ref":"#/components/schemas/v1alpha1.RetryNodeAntiAffinity"}}},"v1alpha1.RetryNodeAntiAffinity":{},"v1alpha1.Backoff":{"properties":{"duration":{"type":"string"},"factor":{"$ref":"#/components/schemas/intstr.IntOrString"},"maxDuration":{"type":"string"}}},"v1.PodSecurityContext":{"description":"PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.","properties":{"fsGroup":{"description":"A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\n\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw ","type":"integer","format":"int64"},"fsGroupChangePolicy":{"description":"fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \"OnRootMismatch\" and \"Always\". If not specified, \"Always\" is used. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"supplementalGroups":{"description":"A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"type":"integer","format":"int64"}},"sysctls":{"description":"Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"$ref":"#/components/schemas/v1.Sysctl"}},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.SELinuxOptions":{"description":"SELinuxOptions are the labels to be applied to the container","properties":{"level":{"description":"Level is SELinux level label that applies to the container.","type":"string"},"role":{"description":"Role is a SELinux role label that applies to the container.","type":"string"},"type":{"description":"Type is a SELinux type label that applies to the container.","type":"string"},"user":{"description":"User is a SELinux user label that applies to the container.","type":"string"}}},"v1.SeccompProfile":{"description":"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.","required":["type"],"properties":{"localhostProfile":{"description":"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is \"Localhost\".","type":"string"},"type":{"description":"type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.","type":"string"}}},"v1.Sysctl":{"description":"Sysctl defines a kernel parameter to be set","required":["name","value"],"properties":{"name":{"description":"Name of a property to set","type":"string"},"value":{"description":"Value of a property to set","type":"string"}}},"v1.WindowsSecurityContextOptions":{"description":"WindowsSecurityContextOptions contain Windows-specific options and credentials.","properties":{"gmsaCredentialSpec":{"description":"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.","type":"string"},"gmsaCredentialSpecName":{"description":"GMSACredentialSpecName is the name of the GMSA credential spec to use.","type":"string"},"hostProcess":{"description":"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.","type":"boolean"},"runAsUserName":{"description":"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"string"}}},"v1alpha1.Synchronization":{"properties":{"mutex":{"$ref":"#/components/schemas/v1alpha1.Mutex"},"semaphore":{"$ref":"#/components/schemas/v1alpha1.SemaphoreRef"}}},"v1alpha1.Mutex":{"properties":{"name":{"type":"string"},"namespace":{"type":"string"}}},"v1alpha1.SemaphoreRef":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"namespace":{"type":"string"}}},"v1alpha1.Template":{"properties":{"activeDeadlineSeconds":{"$ref":"#/components/schemas/intstr.IntOrString"},"affinity":{"$ref":"#/components/schemas/v1.Affinity"},"archiveLocation":{"$ref":"#/components/schemas/v1alpha1.ArtifactLocation"},"automountServiceAccountToken":{"type":"boolean"},"container":{"$ref":"#/components/schemas/v1.Container"},"containerSet":{"$ref":"#/components/schemas/v1alpha1.ContainerSetTemplate"},"daemon":{"type":"boolean"},"dag":{"$ref":"#/components/schemas/v1alpha1.DAGTemplate"},"data":{"$ref":"#/components/schemas/v1alpha1.Data"},"executor":{"$ref":"#/components/schemas/v1alpha1.ExecutorConfig"},"failFast":{"type":"boolean"},"hostAliases":{"type":"array","items":{"$ref":"#/components/schemas/v1.HostAlias"}},"http":{"$ref":"#/components/schemas/v1alpha1.HTTP"},"initContainers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"inputs":{"$ref":"#/components/schemas/v1alpha1.Inputs"},"memoize":{"$ref":"#/components/schemas/v1alpha1.Memoize"},"metadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"metrics":{"$ref":"#/components/schemas/v1alpha1.Metrics"},"name":{"type":"string"},"nodeSelector":{"type":"object","additionalProperties":{"type":"string"}},"outputs":{"$ref":"#/components/schemas/v1alpha1.Outputs"},"parallelism":{"type":"integer","format":"int64"},"plugin":{"$ref":"#/components/schemas/v1alpha1.Plugin"},"podSpecPatch":{"type":"string"},"priority":{"type":"integer","format":"int32"},"priorityClassName":{"type":"string"},"resource":{"$ref":"#/components/schemas/v1alpha1.ResourceTemplate"},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.RetryStrategy"},"schedulerName":{"type":"string"},"script":{"$ref":"#/components/schemas/v1alpha1.ScriptTemplate"},"securityContext":{"$ref":"#/components/schemas/v1.PodSecurityContext"},"serviceAccountName":{"type":"string"},"sidecars":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"steps":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ParallelSteps"}},"suspend":{"$ref":"#/components/schemas/v1alpha1.SuspendTemplate"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.Synchronization"},"timeout":{"type":"string"},"tolerations":{"type":"array","items":{"$ref":"#/components/schemas/v1.Toleration"}},"volumes":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}}}},"v1alpha1.ArtifactLocation":{"properties":{"archiveLogs":{"type":"boolean"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"}}},"v1.Container":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1.EnvVar":{"description":"EnvVar represents an environment variable present in a Container.","required":["name"],"properties":{"name":{"description":"Name of the environment variable. Must be a C_IDENTIFIER.","type":"string"},"value":{"description":"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".","type":"string"},"valueFrom":{"description":"Source for the environment variable's value. Cannot be used if value is not empty.","$ref":"#/components/schemas/v1.EnvVarSource"}}},"v1.EnvVarSource":{"description":"EnvVarSource represents a source for the value of an EnvVar.","properties":{"configMapKeyRef":{"description":"Selects a key of a ConfigMap.","$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"fieldRef":{"description":"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"},"secretKeyRef":{"description":"Selects a key of a secret in the pod's namespace","$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.EnvFromSource":{"description":"EnvFromSource represents the source of a set of ConfigMaps","properties":{"configMapRef":{"description":"The ConfigMap to select from","$ref":"#/components/schemas/v1.ConfigMapEnvSource"},"prefix":{"description":"An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.","type":"string"},"secretRef":{"description":"The Secret to select from","$ref":"#/components/schemas/v1.SecretEnvSource"}}},"v1.ConfigMapEnvSource":{"description":"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap must be defined","type":"boolean"}}},"v1.SecretEnvSource":{"description":"SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret must be defined","type":"boolean"}}},"v1.Lifecycle":{"description":"Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.","properties":{"postStart":{"description":"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"},"preStop":{"description":"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"}}},"v1.LifecycleHandler":{"description":"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"tcpSocket":{"description":"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.","$ref":"#/components/schemas/v1.TCPSocketAction"}}},"v1.ExecAction":{"description":"ExecAction describes a \"run in container\" action.","properties":{"command":{"description":"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.","type":"array","items":{"type":"string"}}}},"v1.HTTPGetAction":{"description":"HTTPGetAction describes an action based on HTTP Get requests.","required":["port"],"properties":{"host":{"description":"Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.","type":"string"},"httpHeaders":{"description":"Custom headers to set in the request. HTTP allows repeated headers.","type":"array","items":{"$ref":"#/components/schemas/v1.HTTPHeader"}},"path":{"description":"Path to access on the HTTP server.","type":"string"},"port":{"description":"Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"},"scheme":{"description":"Scheme to use for connecting to the host. Defaults to HTTP.","type":"string"}}},"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}},"v1.TCPSocketAction":{"description":"TCPSocketAction describes an action based on opening a socket","required":["port"],"properties":{"host":{"description":"Optional: Host name to connect to, defaults to the pod IP.","type":"string"},"port":{"description":"Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"}}},"v1.Probe":{"description":"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"failureThreshold":{"description":"Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.","type":"integer","format":"int32"},"grpc":{"description":"GRPC specifies an action involving a GRPC port. This is a beta field and requires enabling GRPCContainerProbe feature gate.","$ref":"#/components/schemas/v1.GRPCAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"initialDelaySeconds":{"description":"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"},"periodSeconds":{"description":"How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.","type":"integer","format":"int32"},"successThreshold":{"description":"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.","type":"integer","format":"int32"},"tcpSocket":{"description":"TCPSocket specifies an action involving a TCP port.","$ref":"#/components/schemas/v1.TCPSocketAction"},"terminationGracePeriodSeconds":{"description":"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.","type":"integer","format":"int64"},"timeoutSeconds":{"description":"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"}}},"v1.GRPCAction":{"required":["port","service"],"properties":{"port":{"description":"Port number of the gRPC service. Number must be in the range 1 to 65535.","type":"integer","format":"int32"},"service":{"description":"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.","type":"string"}}},"v1.ContainerPort":{"description":"ContainerPort represents a network port in a single container.","required":["containerPort"],"properties":{"containerPort":{"description":"Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.","type":"integer","format":"int32"},"hostIP":{"description":"What host IP to bind the external port to.","type":"string"},"hostPort":{"description":"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.","type":"integer","format":"int32"},"name":{"description":"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.","type":"string"},"protocol":{"description":"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"v1.SecurityContext":{"description":"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.","properties":{"allowPrivilegeEscalation":{"description":"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"capabilities":{"description":"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.Capabilities"},"privileged":{"description":"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"procMount":{"description":"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"readOnlyRootFilesystem":{"description":"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Capabilities":{"description":"Adds and removes POSIX capabilities from running containers.","properties":{"add":{"description":"Added capabilities","type":"array","items":{"type":"string"}},"drop":{"description":"Removed capabilities","type":"array","items":{"type":"string"}}}},"v1.VolumeDevice":{"description":"volumeDevice describes a mapping of a raw block device within a container.","required":["name","devicePath"],"properties":{"devicePath":{"description":"devicePath is the path inside of the container that the device will be mapped to.","type":"string"},"name":{"description":"name must match the name of a persistentVolumeClaim in the pod","type":"string"}}},"v1.VolumeMount":{"description":"VolumeMount describes a mounting of a Volume within a container.","required":["name","mountPath"],"properties":{"mountPath":{"description":"Path within the container at which the volume should be mounted. Must not contain ':'.","type":"string"},"mountPropagation":{"description":"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10.","type":"string"},"name":{"description":"This must match the Name of a Volume.","type":"string"},"readOnly":{"description":"Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.","type":"boolean"},"subPath":{"description":"Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).","type":"string"},"subPathExpr":{"description":"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.","type":"string"}}},"v1alpha1.ContainerSetTemplate":{"required":["containers"],"properties":{"containers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ContainerNode"}},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.ContainerSetRetryStrategy"},"volumeMounts":{"type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}}}},"v1alpha1.ContainerNode":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"dependencies":{"type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.ContainerSetRetryStrategy":{"required":["retries"],"properties":{"duration":{"type":"string"},"retries":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"v1alpha1.DAGTemplate":{"required":["tasks"],"properties":{"failFast":{"type":"boolean"},"target":{"type":"string"},"tasks":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.DAGTask"}}}},"v1alpha1.DAGTask":{"required":["name"],"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"continueOn":{"$ref":"#/components/schemas/v1alpha1.ContinueOn"},"dependencies":{"type":"array","items":{"type":"string"}},"depends":{"type":"string"},"hooks":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LifecycleHook"}},"inline":{"$ref":"#/components/schemas/v1alpha1.Template"},"name":{"type":"string"},"onExit":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"},"when":{"type":"string"},"withItems":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Item"}},"withParam":{"type":"string"},"withSequence":{"$ref":"#/components/schemas/v1alpha1.Sequence"}}},"v1alpha1.ContinueOn":{"properties":{"error":{"type":"boolean"},"failed":{"type":"boolean"}}},"v1alpha1.Item":{},"v1alpha1.Sequence":{"properties":{"count":{"$ref":"#/components/schemas/intstr.IntOrString"},"end":{"$ref":"#/components/schemas/intstr.IntOrString"},"format":{"type":"string"},"start":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"v1alpha1.Data":{"required":["source","transformation"],"properties":{"source":{"$ref":"#/components/schemas/v1alpha1.DataSource"},"transformation":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.TransformationStep"}}}},"v1alpha1.DataSource":{"properties":{"artifactPaths":{"$ref":"#/components/schemas/v1alpha1.ArtifactPaths"}}},"v1alpha1.ArtifactPaths":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.TransformationStep":{"required":["expression"],"properties":{"expression":{"type":"string"}}},"v1alpha1.HTTP":{"required":["url"],"properties":{"body":{"type":"string"},"bodyFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPBodySource"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.HTTPHeader"}},"insecureSkipVerify":{"type":"boolean"},"method":{"type":"string"},"successCondition":{"type":"string"},"timeoutSeconds":{"type":"integer","format":"int64"},"url":{"type":"string"}}},"v1alpha1.HTTPBodySource":{"properties":{"bytes":{"type":"string"}}},"v1alpha1.HTTPHeader":{"required":["name"],"properties":{"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPHeaderSource"}}},"v1alpha1.HTTPHeaderSource":{"properties":{"secretKeyRef":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.UserContainer":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"mirrorVolumeMounts":{"type":"boolean"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.Inputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Memoize":{"required":["key","cache","maxAge"],"properties":{"cache":{"$ref":"#/components/schemas/v1alpha1.Cache"},"key":{"type":"string"},"maxAge":{"type":"string"}}},"v1alpha1.Cache":{"required":["configMap"],"properties":{"configMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"}}},"v1alpha1.Outputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"exitCode":{"type":"string"},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}},"result":{"type":"string"}}},"v1alpha1.Plugin":{},"v1alpha1.ResourceTemplate":{"required":["action"],"properties":{"action":{"type":"string"},"failureCondition":{"type":"string"},"flags":{"type":"array","items":{"type":"string"}},"manifest":{"type":"string"},"manifestFrom":{"$ref":"#/components/schemas/v1alpha1.ManifestFrom"},"mergeStrategy":{"type":"string"},"setOwnerReference":{"type":"boolean"},"successCondition":{"type":"string"}}},"v1alpha1.ManifestFrom":{"required":["artifact"],"properties":{"artifact":{"$ref":"#/components/schemas/v1alpha1.Artifact"}}},"v1alpha1.ScriptTemplate":{"description":"A single application container that you want to run within a pod.","required":["name","source"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"source":{"type":"string"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.ParallelSteps":{},"v1alpha1.SuspendTemplate":{"properties":{"duration":{"type":"string"}}},"v1.Toleration":{"description":"The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .","properties":{"effect":{"description":"Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.","type":"string"},"key":{"description":"Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.","type":"string"},"operator":{"description":"Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.","type":"string"},"tolerationSeconds":{"description":"TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.","type":"integer","format":"int64"},"value":{"description":"Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.","type":"string"}}},"v1.Volume":{"description":"Volume represents a named volume in a pod that may be accessed by any container in the pod.","required":["name"],"properties":{"awsElasticBlockStore":{"description":"awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","$ref":"#/components/schemas/v1.AWSElasticBlockStoreVolumeSource"},"azureDisk":{"description":"azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureDiskVolumeSource"},"azureFile":{"description":"azureFile represents an Azure File Service mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureFileVolumeSource"},"cephfs":{"description":"cephFS represents a Ceph FS mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.CephFSVolumeSource"},"cinder":{"description":"cinder represents a cinder volume attached and mounted on kubelets host machine. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","$ref":"#/components/schemas/v1.CinderVolumeSource"},"configMap":{"description":"configMap represents a configMap that should populate this volume","$ref":"#/components/schemas/v1.ConfigMapVolumeSource"},"csi":{"description":"csi (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers (Beta feature).","$ref":"#/components/schemas/v1.CSIVolumeSource"},"downwardAPI":{"description":"downwardAPI represents downward API about the pod that should populate this volume","$ref":"#/components/schemas/v1.DownwardAPIVolumeSource"},"emptyDir":{"description":"emptyDir represents a temporary directory that shares a pod's lifetime. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","$ref":"#/components/schemas/v1.EmptyDirVolumeSource"},"ephemeral":{"description":"ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed.\n\nUse this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity\n tracking are needed,\nc) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through\n a PersistentVolumeClaim (see EphemeralVolumeSource for more\n information on the connection between this volume type\n and PersistentVolumeClaim).\n\nUse PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod.\n\nUse CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information.\n\nA pod can use both types of ephemeral volumes and persistent volumes at the same time.","$ref":"#/components/schemas/v1.EphemeralVolumeSource"},"fc":{"description":"fc represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.","$ref":"#/components/schemas/v1.FCVolumeSource"},"flexVolume":{"description":"flexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","$ref":"#/components/schemas/v1.FlexVolumeSource"},"flocker":{"description":"flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running","$ref":"#/components/schemas/v1.FlockerVolumeSource"},"gcePersistentDisk":{"description":"gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","$ref":"#/components/schemas/v1.GCEPersistentDiskVolumeSource"},"gitRepo":{"description":"gitRepo represents a git repository at a particular revision. DEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","$ref":"#/components/schemas/v1.GitRepoVolumeSource"},"glusterfs":{"description":"glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/glusterfs/README.md","$ref":"#/components/schemas/v1.GlusterfsVolumeSource"},"hostPath":{"description":"hostPath represents a pre-existing file or directory on the host machine that is directly exposed to the container. This is generally used for system agents or other privileged things that are allowed to see the host machine. Most containers will NOT need this. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","$ref":"#/components/schemas/v1.HostPathVolumeSource"},"iscsi":{"description":"iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://examples.k8s.io/volumes/iscsi/README.md","$ref":"#/components/schemas/v1.ISCSIVolumeSource"},"name":{"description":"name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"nfs":{"description":"nfs represents an NFS mount on the host that shares a pod's lifetime More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","$ref":"#/components/schemas/v1.NFSVolumeSource"},"persistentVolumeClaim":{"description":"persistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimVolumeSource"},"photonPersistentDisk":{"description":"photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PhotonPersistentDiskVolumeSource"},"portworxVolume":{"description":"portworxVolume represents a portworx volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PortworxVolumeSource"},"projected":{"description":"projected items for all in one resources secrets, configmaps, and downward API","$ref":"#/components/schemas/v1.ProjectedVolumeSource"},"quobyte":{"description":"quobyte represents a Quobyte mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.QuobyteVolumeSource"},"rbd":{"description":"rbd represents a Rados Block Device mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/rbd/README.md","$ref":"#/components/schemas/v1.RBDVolumeSource"},"scaleIO":{"description":"scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.ScaleIOVolumeSource"},"secret":{"description":"secret represents a secret that should populate this volume. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","$ref":"#/components/schemas/v1.SecretVolumeSource"},"storageos":{"description":"storageOS represents a StorageOS volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.StorageOSVolumeSource"},"vsphereVolume":{"description":"vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.VsphereVirtualDiskVolumeSource"}}},"v1.AWSElasticBlockStoreVolumeSource":{"description":"Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).","type":"integer","format":"int32"},"readOnly":{"description":"readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"boolean"},"volumeID":{"description":"volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"}}},"v1.AzureDiskVolumeSource":{"description":"AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","required":["diskName","diskURI"],"properties":{"cachingMode":{"description":"cachingMode is the Host Caching mode: None, Read Only, Read Write.","type":"string"},"diskName":{"description":"diskName is the Name of the data disk in the blob storage","type":"string"},"diskURI":{"description":"diskURI is the URI of data disk in the blob storage","type":"string"},"fsType":{"description":"fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"kind":{"description":"kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"}}},"v1.AzureFileVolumeSource":{"description":"AzureFile represents an Azure File Service mount on the host and bind mount to the pod.","required":["secretName","shareName"],"properties":{"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretName":{"description":"secretName is the name of secret that contains Azure Storage Account Name and Key","type":"string"},"shareName":{"description":"shareName is the azure share Name","type":"string"}}},"v1.CephFSVolumeSource":{"description":"Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.","required":["monitors"],"properties":{"monitors":{"description":"monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"path":{"description":"path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /","type":"string"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"boolean"},"secretFile":{"description":"secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"},"secretRef":{"description":"secretRef is Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"}}},"v1.CinderVolumeSource":{"description":"Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"boolean"},"secretRef":{"description":"secretRef is optional: points to a secret object containing parameters used to connect to OpenStack.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeID":{"description":"volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"}}},"v1.ConfigMapVolumeSource":{"description":"Adapts a ConfigMap into a volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.KeyToPath":{"description":"Maps a string key to a path within a volume.","required":["key","path"],"properties":{"key":{"description":"key is the key to project.","type":"string"},"mode":{"description":"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.","type":"string"}}},"v1.CSIVolumeSource":{"description":"Represents a source location of a volume to mount, managed by an external CSI driver","required":["driver"],"properties":{"driver":{"description":"driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.","type":"string"},"fsType":{"description":"fsType to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.","type":"string"},"nodePublishSecretRef":{"description":"nodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secret references are passed.","$ref":"#/components/schemas/v1.LocalObjectReference"},"readOnly":{"description":"readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).","type":"boolean"},"volumeAttributes":{"description":"volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.","type":"object","additionalProperties":{"type":"string"}}}},"v1.DownwardAPIVolumeSource":{"description":"DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"Items is a list of downward API volume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.DownwardAPIVolumeFile":{"description":"DownwardAPIVolumeFile represents information to create the file containing the pod field","required":["path"],"properties":{"fieldRef":{"description":"Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"mode":{"description":"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'","type":"string"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"}}},"v1.EmptyDirVolumeSource":{"description":"Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.","properties":{"medium":{"description":"medium represents what type of storage medium should back this directory. The default is \"\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","type":"string"},"sizeLimit":{"description":"sizeLimit is the total amount of local storage required for this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. The default is nil which means that the limit is undefined. More info: http://kubernetes.io/docs/user-guide/volumes#emptydir","$ref":"#/components/schemas/resource.Quantity"}}},"v1.EphemeralVolumeSource":{"description":"Represents an ephemeral volume that is handled by a normal storage driver.","properties":{"volumeClaimTemplate":{"description":"Will be used to create a stand-alone PVC to provision the volume. The pod in which this EphemeralVolumeSource is embedded will be the owner of the PVC, i.e. the PVC will be deleted together with the pod. The name of the PVC will be `-` where `` is the name from the `PodSpec.Volumes` array entry. Pod validation will reject the pod if the concatenated name is not valid for a PVC (for example, too long).\n\nAn existing PVC with that name that is not owned by the pod will *not* be used for the pod to avoid using an unrelated volume by mistake. Starting the pod is then blocked until the unrelated PVC is removed. If such a pre-created PVC is meant to be used by the pod, the PVC has to updated with an owner reference to the pod once the pod exists. Normally this should not be necessary, but it may be useful when manually reconstructing a broken cluster.\n\nThis field is read-only and no changes will be made by Kubernetes to the PVC after it has been created.\n\nRequired, must not be nil.","$ref":"#/components/schemas/v1.PersistentVolumeClaimTemplate"}}},"v1.PersistentVolumeClaimTemplate":{"description":"PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.","required":["spec"],"properties":{"metadata":{"description":"May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"The specification for the PersistentVolumeClaim. The entire content is copied unchanged into the PVC that gets created from this template. The same fields as in a PersistentVolumeClaim are also valid here.","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"}}},"v1.PersistentVolumeClaimSpec":{"description":"PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes","properties":{"accessModes":{"description":"accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"dataSource":{"description":"dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"dataSourceRef":{"description":"dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"resources":{"description":"resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources","$ref":"#/components/schemas/v1.ResourceRequirements"},"selector":{"description":"selector is a label query over volumes to consider for binding.","$ref":"#/components/schemas/v1.LabelSelector"},"storageClassName":{"description":"storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1","type":"string"},"volumeMode":{"description":"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.","type":"string"},"volumeName":{"description":"volumeName is the binding reference to the PersistentVolume backing this claim.","type":"string"}}},"v1.TypedLocalObjectReference":{"description":"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.","required":["apiGroup","kind","name"],"properties":{"apiGroup":{"description":"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.","type":"string"},"kind":{"description":"Kind is the type of resource being referenced","type":"string"},"name":{"description":"Name is the name of resource being referenced","type":"string"}}},"v1.FCVolumeSource":{"description":"Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"lun":{"description":"lun is Optional: FC target lun number","type":"integer","format":"int32"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"targetWWNs":{"description":"targetWWNs is Optional: FC target worldwide names (WWNs)","type":"array","items":{"type":"string"}},"wwids":{"description":"wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.","type":"array","items":{"type":"string"}}}},"v1.FlexVolumeSource":{"description":"FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","required":["driver"],"properties":{"driver":{"description":"driver is the name of the driver to use for this volume.","type":"string"},"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.","type":"string"},"options":{"description":"options is Optional: this field holds extra command options if any.","type":"object","additionalProperties":{"type":"string"}},"readOnly":{"description":"readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef is Optional: secretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts.","$ref":"#/components/schemas/v1.LocalObjectReference"}}},"v1.FlockerVolumeSource":{"description":"Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.","properties":{"datasetName":{"description":"datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated","type":"string"},"datasetUUID":{"description":"datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset","type":"string"}}},"v1.GCEPersistentDiskVolumeSource":{"description":"Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.","required":["pdName"],"properties":{"fsType":{"description":"fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"integer","format":"int32"},"pdName":{"description":"pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"boolean"}}},"v1.GitRepoVolumeSource":{"description":"Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","required":["repository"],"properties":{"directory":{"description":"directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.","type":"string"},"repository":{"description":"repository is the URL","type":"string"},"revision":{"description":"revision is the commit hash for the specified revision.","type":"string"}}},"v1.GlusterfsVolumeSource":{"description":"Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.","required":["endpoints","path"],"properties":{"endpoints":{"description":"endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"path":{"description":"path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"readOnly":{"description":"readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"boolean"}}},"v1.HostPathVolumeSource":{"description":"Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.","required":["path"],"properties":{"path":{"description":"path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"},"type":{"description":"type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"}}},"v1.ISCSIVolumeSource":{"description":"Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.","required":["targetPortal","iqn","lun"],"properties":{"chapAuthDiscovery":{"description":"chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication","type":"boolean"},"chapAuthSession":{"description":"chapAuthSession defines whether support iSCSI Session CHAP authentication","type":"boolean"},"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi","type":"string"},"initiatorName":{"description":"initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.","type":"string"},"iqn":{"description":"iqn is the target iSCSI Qualified Name.","type":"string"},"iscsiInterface":{"description":"iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).","type":"string"},"lun":{"description":"lun represents iSCSI Target Lun number.","type":"integer","format":"int32"},"portals":{"description":"portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"array","items":{"type":"string"}},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.","type":"boolean"},"secretRef":{"description":"secretRef is the CHAP Secret for iSCSI target and initiator authentication","$ref":"#/components/schemas/v1.LocalObjectReference"},"targetPortal":{"description":"targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"string"}}},"v1.NFSVolumeSource":{"description":"Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.","required":["server","path"],"properties":{"path":{"description":"path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"},"readOnly":{"description":"readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"boolean"},"server":{"description":"server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"}}},"v1.PersistentVolumeClaimVolumeSource":{"description":"PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).","required":["claimName"],"properties":{"claimName":{"description":"claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","type":"string"},"readOnly":{"description":"readOnly Will force the ReadOnly setting in VolumeMounts. Default false.","type":"boolean"}}},"v1.PhotonPersistentDiskVolumeSource":{"description":"Represents a Photon Controller persistent disk resource.","required":["pdID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"pdID":{"description":"pdID is the ID that identifies Photon Controller persistent disk","type":"string"}}},"v1.PortworxVolumeSource":{"description":"PortworxVolumeSource represents a Portworx volume resource.","required":["volumeID"],"properties":{"fsType":{"description":"fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"volumeID":{"description":"volumeID uniquely identifies a Portworx volume","type":"string"}}},"v1.ProjectedVolumeSource":{"description":"Represents a projected volume source","required":["sources"],"properties":{"defaultMode":{"description":"defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"sources":{"description":"sources is the list of volume projections","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeProjection"}}}},"v1.VolumeProjection":{"description":"Projection that may be projected along with other supported volume types","properties":{"configMap":{"description":"configMap information about the configMap data to project","$ref":"#/components/schemas/v1.ConfigMapProjection"},"downwardAPI":{"description":"downwardAPI information about the downwardAPI data to project","$ref":"#/components/schemas/v1.DownwardAPIProjection"},"secret":{"description":"secret information about the secret data to project","$ref":"#/components/schemas/v1.SecretProjection"},"serviceAccountToken":{"description":"serviceAccountToken is information about the serviceAccountToken data to project","$ref":"#/components/schemas/v1.ServiceAccountTokenProjection"}}},"v1.ConfigMapProjection":{"description":"Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.DownwardAPIProjection":{"description":"Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.","properties":{"items":{"description":"Items is a list of DownwardAPIVolume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.SecretProjection":{"description":"Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional field specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.ServiceAccountTokenProjection":{"description":"ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).","required":["path"],"properties":{"audience":{"description":"audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.","type":"string"},"expirationSeconds":{"description":"expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.","type":"integer","format":"int64"},"path":{"description":"path is the path relative to the mount point of the file to project the token into.","type":"string"}}},"v1.QuobyteVolumeSource":{"description":"Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.","required":["registry","volume"],"properties":{"group":{"description":"group to map volume access to Default is no group","type":"string"},"readOnly":{"description":"readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.","type":"boolean"},"registry":{"description":"registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes","type":"string"},"tenant":{"description":"tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin","type":"string"},"user":{"description":"user to map volume access to Defaults to serivceaccount user","type":"string"},"volume":{"description":"volume is a string that references an already created Quobyte volume by name.","type":"string"}}},"v1.RBDVolumeSource":{"description":"Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.","required":["monitors","image"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd","type":"string"},"image":{"description":"image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"keyring":{"description":"keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"monitors":{"description":"monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"pool":{"description":"pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"boolean"},"secretRef":{"description":"secretRef is name of the authentication secret for RBDUser. If provided overrides keyring. Default is nil. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"}}},"v1.ScaleIOVolumeSource":{"description":"ScaleIOVolumeSource represents a persistent ScaleIO volume","required":["gateway","system","secretRef"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\".","type":"string"},"gateway":{"description":"gateway is the host address of the ScaleIO API Gateway.","type":"string"},"protectionDomain":{"description":"protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef references to the secret for ScaleIO user and other sensitive information. If this is not provided, Login operation will fail.","$ref":"#/components/schemas/v1.LocalObjectReference"},"sslEnabled":{"description":"sslEnabled Flag enable/disable SSL communication with Gateway, default false","type":"boolean"},"storageMode":{"description":"storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.","type":"string"},"storagePool":{"description":"storagePool is the ScaleIO Storage Pool associated with the protection domain.","type":"string"},"system":{"description":"system is the name of the storage system as configured in ScaleIO.","type":"string"},"volumeName":{"description":"volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.","type":"string"}}},"v1.SecretVolumeSource":{"description":"Adapts a Secret into a volume.\n\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"optional":{"description":"optional field specify whether the Secret or its keys must be defined","type":"boolean"},"secretName":{"description":"secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","type":"string"}}},"v1.StorageOSVolumeSource":{"description":"Represents a StorageOS persistent volume resource.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeName":{"description":"volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.","type":"string"},"volumeNamespace":{"description":"volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.","type":"string"}}},"v1.VsphereVirtualDiskVolumeSource":{"description":"Represents a vSphere volume resource.","required":["volumePath"],"properties":{"fsType":{"description":"fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"storagePolicyID":{"description":"storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.","type":"string"},"storagePolicyName":{"description":"storagePolicyName is the storage Policy Based Management (SPBM) profile name.","type":"string"},"volumePath":{"description":"volumePath is the path that identifies vSphere volume vmdk","type":"string"}}},"v1alpha1.TTLStrategy":{"properties":{"secondsAfterCompletion":{"type":"integer","format":"int32"},"secondsAfterFailure":{"type":"integer","format":"int32"},"secondsAfterSuccess":{"type":"integer","format":"int32"}}},"v1alpha1.VolumeClaimGC":{"properties":{"strategy":{"type":"string"}}},"v1.PersistentVolumeClaim":{"description":"PersistentVolumeClaim is a user's request for and claim to a persistent volume","properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"description":"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"spec defines the desired characteristics of a volume requested by a pod author. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"},"status":{"description":"status represents the current information/status of a persistent volume claim. Read-only. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimStatus"}}},"v1.PersistentVolumeClaimStatus":{"description":"PersistentVolumeClaimStatus is the current status of a persistent volume claim.","properties":{"accessModes":{"description":"accessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"allocatedResources":{"description":"allocatedResources is the storage resource within AllocatedResources tracks the capacity allocated to a PVC. It may be larger than the actual capacity when a volume expansion operation is requested. For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. If a volume expansion capacity request is lowered, allocatedResources is only lowered if there are no expansion operations in progress and if the actual volume capacity is equal or lower than the requested capacity. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"capacity":{"description":"capacity represents the actual resources of the underlying volume.","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"conditions":{"description":"conditions is the current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'ResizeStarted'.","type":"array","items":{"$ref":"#/components/schemas/v1.PersistentVolumeClaimCondition"}},"phase":{"description":"phase represents the current phase of PersistentVolumeClaim.","type":"string"},"resizeStatus":{"description":"resizeStatus stores status of resize operation. ResizeStatus is not set by default but when expansion is complete resizeStatus is set to empty string by resize controller or kubelet. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.","type":"string"}}},"v1.PersistentVolumeClaimCondition":{"description":"PersistentVolumeClaimCondition contails details about state of pvc","required":["type","status"],"properties":{"lastProbeTime":{"description":"lastProbeTime is the time we probed the condition.","$ref":"#/components/schemas/v1.Time"},"lastTransitionTime":{"description":"lastTransitionTime is the time the condition transitioned from one status to another.","$ref":"#/components/schemas/v1.Time"},"message":{"description":"message is the human-readable message indicating details about last transition.","type":"string"},"reason":{"description":"reason is a unique, this should be a short, machine understandable string that gives the reason for condition's last transition. If it reports \"ResizeStarted\" that means the underlying persistent volume is being resized.","type":"string"},"status":{"type":"string"},"type":{"type":"string"}}},"v1alpha1.WorkflowMetadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}},"labelsFrom":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LabelValueFrom"}}}},"v1alpha1.LabelValueFrom":{"required":["expression"],"properties":{"expression":{"type":"string"}}},"v1alpha1.WorkflowTemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"}}}}}} ``` ## The v1alpha1.CronWorkflowStatus object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.CronWorkflowStatus":{"required":["active","lastScheduledTime","conditions"],"properties":{"active":{"type":"array","items":{"$ref":"#/components/schemas/v1.ObjectReference"}},"conditions":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Condition"}},"lastScheduledTime":{"$ref":"#/components/schemas/v1.Time"}}},"v1.ObjectReference":{"description":"ObjectReference contains enough information to let you inspect or modify the referred object.","properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"fieldPath":{"description":"If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \"spec.containers{name}\" (where \"name\" refers to the name of the container that triggered the event) or if no container name is specified \"spec.containers[2]\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object.","type":"string"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"namespace":{"description":"Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/","type":"string"},"resourceVersion":{"description":"Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency","type":"string"},"uid":{"description":"UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids","type":"string"}}},"v1alpha1.Condition":{"properties":{"message":{"type":"string"},"status":{"type":"string"},"type":{"type":"string"}}},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}}}}} ``` ## The v1alpha1.DAGTask object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.DAGTask":{"required":["name"],"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"continueOn":{"$ref":"#/components/schemas/v1alpha1.ContinueOn"},"dependencies":{"type":"array","items":{"type":"string"}},"depends":{"type":"string"},"hooks":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LifecycleHook"}},"inline":{"$ref":"#/components/schemas/v1alpha1.Template"},"name":{"type":"string"},"onExit":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"},"when":{"type":"string"},"withItems":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Item"}},"withParam":{"type":"string"},"withSequence":{"$ref":"#/components/schemas/v1alpha1.Sequence"}}},"v1alpha1.Arguments":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Artifact":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.Parameter":{"required":["name"],"properties":{"default":{"type":"string"},"description":{"type":"string"},"enum":{"type":"array","items":{"type":"string"}},"globalName":{"type":"string"},"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.ValueFrom"}}},"v1alpha1.ValueFrom":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"default":{"type":"string"},"event":{"type":"string"},"expression":{"type":"string"},"jqFilter":{"type":"string"},"jsonPath":{"type":"string"},"parameter":{"type":"string"},"path":{"type":"string"},"supplied":{"$ref":"#/components/schemas/v1alpha1.SuppliedValueFrom"}}},"v1alpha1.SuppliedValueFrom":{},"v1alpha1.ContinueOn":{"properties":{"error":{"type":"boolean"},"failed":{"type":"boolean"}}},"v1alpha1.LifecycleHook":{"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"expression":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"}}},"v1alpha1.TemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"},"template":{"type":"string"}}},"v1alpha1.Template":{"properties":{"activeDeadlineSeconds":{"$ref":"#/components/schemas/intstr.IntOrString"},"affinity":{"$ref":"#/components/schemas/v1.Affinity"},"archiveLocation":{"$ref":"#/components/schemas/v1alpha1.ArtifactLocation"},"automountServiceAccountToken":{"type":"boolean"},"container":{"$ref":"#/components/schemas/v1.Container"},"containerSet":{"$ref":"#/components/schemas/v1alpha1.ContainerSetTemplate"},"daemon":{"type":"boolean"},"dag":{"$ref":"#/components/schemas/v1alpha1.DAGTemplate"},"data":{"$ref":"#/components/schemas/v1alpha1.Data"},"executor":{"$ref":"#/components/schemas/v1alpha1.ExecutorConfig"},"failFast":{"type":"boolean"},"hostAliases":{"type":"array","items":{"$ref":"#/components/schemas/v1.HostAlias"}},"http":{"$ref":"#/components/schemas/v1alpha1.HTTP"},"initContainers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"inputs":{"$ref":"#/components/schemas/v1alpha1.Inputs"},"memoize":{"$ref":"#/components/schemas/v1alpha1.Memoize"},"metadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"metrics":{"$ref":"#/components/schemas/v1alpha1.Metrics"},"name":{"type":"string"},"nodeSelector":{"type":"object","additionalProperties":{"type":"string"}},"outputs":{"$ref":"#/components/schemas/v1alpha1.Outputs"},"parallelism":{"type":"integer","format":"int64"},"plugin":{"$ref":"#/components/schemas/v1alpha1.Plugin"},"podSpecPatch":{"type":"string"},"priority":{"type":"integer","format":"int32"},"priorityClassName":{"type":"string"},"resource":{"$ref":"#/components/schemas/v1alpha1.ResourceTemplate"},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.RetryStrategy"},"schedulerName":{"type":"string"},"script":{"$ref":"#/components/schemas/v1alpha1.ScriptTemplate"},"securityContext":{"$ref":"#/components/schemas/v1.PodSecurityContext"},"serviceAccountName":{"type":"string"},"sidecars":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"steps":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ParallelSteps"}},"suspend":{"$ref":"#/components/schemas/v1alpha1.SuspendTemplate"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.Synchronization"},"timeout":{"type":"string"},"tolerations":{"type":"array","items":{"$ref":"#/components/schemas/v1.Toleration"}},"volumes":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}},"v1.Affinity":{"description":"Affinity is a group of affinity scheduling rules.","properties":{"nodeAffinity":{"description":"Describes node affinity scheduling rules for the pod.","$ref":"#/components/schemas/v1.NodeAffinity"},"podAffinity":{"description":"Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAffinity"},"podAntiAffinity":{"description":"Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAntiAffinity"}}},"v1.NodeAffinity":{"description":"Node affinity is a group of node affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.PreferredSchedulingTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.","$ref":"#/components/schemas/v1.NodeSelector"}}},"v1.PreferredSchedulingTerm":{"description":"An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).","required":["weight","preference"],"properties":{"preference":{"description":"A node selector term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.NodeSelectorTerm"},"weight":{"description":"Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.NodeSelectorTerm":{"description":"A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.","properties":{"matchExpressions":{"description":"A list of node selector requirements by node's labels.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}},"matchFields":{"description":"A list of node selector requirements by node's fields.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}}}},"v1.NodeSelectorRequirement":{"description":"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"The label key that the selector applies to.","type":"string"},"operator":{"description":"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.","type":"string"},"values":{"description":"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.NodeSelector":{"description":"A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.","required":["nodeSelectorTerms"],"properties":{"nodeSelectorTerms":{"description":"Required. A list of node selector terms. The terms are ORed.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorTerm"}}}},"v1.PodAffinity":{"description":"Pod affinity is a group of inter pod affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1.WeightedPodAffinityTerm":{"description":"The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)","required":["weight","podAffinityTerm"],"properties":{"podAffinityTerm":{"description":"Required. A pod affinity term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.PodAffinityTerm"},"weight":{"description":"weight associated with matching the corresponding podAffinityTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.PodAffinityTerm":{"description":"Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running","required":["topologyKey"],"properties":{"labelSelector":{"description":"A label query over a set of resources, in this case pods.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaceSelector":{"description":"A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means \"this pod's namespace\". An empty selector ({}) matches all namespaces.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaces":{"description":"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".","type":"array","items":{"type":"string"}},"topologyKey":{"description":"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.","type":"string"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.PodAntiAffinity":{"description":"Pod anti affinity is a group of inter pod anti affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1alpha1.ArtifactLocation":{"properties":{"archiveLogs":{"type":"boolean"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"}}},"v1.Container":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1.EnvVar":{"description":"EnvVar represents an environment variable present in a Container.","required":["name"],"properties":{"name":{"description":"Name of the environment variable. Must be a C_IDENTIFIER.","type":"string"},"value":{"description":"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".","type":"string"},"valueFrom":{"description":"Source for the environment variable's value. Cannot be used if value is not empty.","$ref":"#/components/schemas/v1.EnvVarSource"}}},"v1.EnvVarSource":{"description":"EnvVarSource represents a source for the value of an EnvVar.","properties":{"configMapKeyRef":{"description":"Selects a key of a ConfigMap.","$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"fieldRef":{"description":"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"},"secretKeyRef":{"description":"Selects a key of a secret in the pod's namespace","$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.EnvFromSource":{"description":"EnvFromSource represents the source of a set of ConfigMaps","properties":{"configMapRef":{"description":"The ConfigMap to select from","$ref":"#/components/schemas/v1.ConfigMapEnvSource"},"prefix":{"description":"An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.","type":"string"},"secretRef":{"description":"The Secret to select from","$ref":"#/components/schemas/v1.SecretEnvSource"}}},"v1.ConfigMapEnvSource":{"description":"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap must be defined","type":"boolean"}}},"v1.SecretEnvSource":{"description":"SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret must be defined","type":"boolean"}}},"v1.Lifecycle":{"description":"Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.","properties":{"postStart":{"description":"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"},"preStop":{"description":"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"}}},"v1.LifecycleHandler":{"description":"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"tcpSocket":{"description":"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.","$ref":"#/components/schemas/v1.TCPSocketAction"}}},"v1.ExecAction":{"description":"ExecAction describes a \"run in container\" action.","properties":{"command":{"description":"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.","type":"array","items":{"type":"string"}}}},"v1.HTTPGetAction":{"description":"HTTPGetAction describes an action based on HTTP Get requests.","required":["port"],"properties":{"host":{"description":"Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.","type":"string"},"httpHeaders":{"description":"Custom headers to set in the request. HTTP allows repeated headers.","type":"array","items":{"$ref":"#/components/schemas/v1.HTTPHeader"}},"path":{"description":"Path to access on the HTTP server.","type":"string"},"port":{"description":"Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"},"scheme":{"description":"Scheme to use for connecting to the host. Defaults to HTTP.","type":"string"}}},"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}},"v1.TCPSocketAction":{"description":"TCPSocketAction describes an action based on opening a socket","required":["port"],"properties":{"host":{"description":"Optional: Host name to connect to, defaults to the pod IP.","type":"string"},"port":{"description":"Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"}}},"v1.Probe":{"description":"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"failureThreshold":{"description":"Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.","type":"integer","format":"int32"},"grpc":{"description":"GRPC specifies an action involving a GRPC port. This is a beta field and requires enabling GRPCContainerProbe feature gate.","$ref":"#/components/schemas/v1.GRPCAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"initialDelaySeconds":{"description":"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"},"periodSeconds":{"description":"How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.","type":"integer","format":"int32"},"successThreshold":{"description":"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.","type":"integer","format":"int32"},"tcpSocket":{"description":"TCPSocket specifies an action involving a TCP port.","$ref":"#/components/schemas/v1.TCPSocketAction"},"terminationGracePeriodSeconds":{"description":"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.","type":"integer","format":"int64"},"timeoutSeconds":{"description":"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"}}},"v1.GRPCAction":{"required":["port","service"],"properties":{"port":{"description":"Port number of the gRPC service. Number must be in the range 1 to 65535.","type":"integer","format":"int32"},"service":{"description":"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.","type":"string"}}},"v1.ContainerPort":{"description":"ContainerPort represents a network port in a single container.","required":["containerPort"],"properties":{"containerPort":{"description":"Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.","type":"integer","format":"int32"},"hostIP":{"description":"What host IP to bind the external port to.","type":"string"},"hostPort":{"description":"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.","type":"integer","format":"int32"},"name":{"description":"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.","type":"string"},"protocol":{"description":"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"v1.SecurityContext":{"description":"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.","properties":{"allowPrivilegeEscalation":{"description":"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"capabilities":{"description":"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.Capabilities"},"privileged":{"description":"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"procMount":{"description":"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"readOnlyRootFilesystem":{"description":"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Capabilities":{"description":"Adds and removes POSIX capabilities from running containers.","properties":{"add":{"description":"Added capabilities","type":"array","items":{"type":"string"}},"drop":{"description":"Removed capabilities","type":"array","items":{"type":"string"}}}},"v1.SELinuxOptions":{"description":"SELinuxOptions are the labels to be applied to the container","properties":{"level":{"description":"Level is SELinux level label that applies to the container.","type":"string"},"role":{"description":"Role is a SELinux role label that applies to the container.","type":"string"},"type":{"description":"Type is a SELinux type label that applies to the container.","type":"string"},"user":{"description":"User is a SELinux user label that applies to the container.","type":"string"}}},"v1.SeccompProfile":{"description":"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.","required":["type"],"properties":{"localhostProfile":{"description":"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is \"Localhost\".","type":"string"},"type":{"description":"type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.","type":"string"}}},"v1.WindowsSecurityContextOptions":{"description":"WindowsSecurityContextOptions contain Windows-specific options and credentials.","properties":{"gmsaCredentialSpec":{"description":"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.","type":"string"},"gmsaCredentialSpecName":{"description":"GMSACredentialSpecName is the name of the GMSA credential spec to use.","type":"string"},"hostProcess":{"description":"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.","type":"boolean"},"runAsUserName":{"description":"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"string"}}},"v1.VolumeDevice":{"description":"volumeDevice describes a mapping of a raw block device within a container.","required":["name","devicePath"],"properties":{"devicePath":{"description":"devicePath is the path inside of the container that the device will be mapped to.","type":"string"},"name":{"description":"name must match the name of a persistentVolumeClaim in the pod","type":"string"}}},"v1.VolumeMount":{"description":"VolumeMount describes a mounting of a Volume within a container.","required":["name","mountPath"],"properties":{"mountPath":{"description":"Path within the container at which the volume should be mounted. Must not contain ':'.","type":"string"},"mountPropagation":{"description":"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10.","type":"string"},"name":{"description":"This must match the Name of a Volume.","type":"string"},"readOnly":{"description":"Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.","type":"boolean"},"subPath":{"description":"Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).","type":"string"},"subPathExpr":{"description":"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.","type":"string"}}},"v1alpha1.ContainerSetTemplate":{"required":["containers"],"properties":{"containers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ContainerNode"}},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.ContainerSetRetryStrategy"},"volumeMounts":{"type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}}}},"v1alpha1.ContainerNode":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"dependencies":{"type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.ContainerSetRetryStrategy":{"required":["retries"],"properties":{"duration":{"type":"string"},"retries":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"v1alpha1.DAGTemplate":{"required":["tasks"],"properties":{"failFast":{"type":"boolean"},"target":{"type":"string"},"tasks":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.DAGTask"}}}},"v1alpha1.Item":{},"v1alpha1.Sequence":{"properties":{"count":{"$ref":"#/components/schemas/intstr.IntOrString"},"end":{"$ref":"#/components/schemas/intstr.IntOrString"},"format":{"type":"string"},"start":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"v1alpha1.Data":{"required":["source","transformation"],"properties":{"source":{"$ref":"#/components/schemas/v1alpha1.DataSource"},"transformation":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.TransformationStep"}}}},"v1alpha1.DataSource":{"properties":{"artifactPaths":{"$ref":"#/components/schemas/v1alpha1.ArtifactPaths"}}},"v1alpha1.ArtifactPaths":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.TransformationStep":{"required":["expression"],"properties":{"expression":{"type":"string"}}},"v1alpha1.ExecutorConfig":{"properties":{"serviceAccountName":{"type":"string"}}},"v1.HostAlias":{"description":"HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.","properties":{"hostnames":{"description":"Hostnames for the above IP address.","type":"array","items":{"type":"string"}},"ip":{"description":"IP address of the host file entry.","type":"string"}}},"v1alpha1.HTTP":{"required":["url"],"properties":{"body":{"type":"string"},"bodyFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPBodySource"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.HTTPHeader"}},"insecureSkipVerify":{"type":"boolean"},"method":{"type":"string"},"successCondition":{"type":"string"},"timeoutSeconds":{"type":"integer","format":"int64"},"url":{"type":"string"}}},"v1alpha1.HTTPBodySource":{"properties":{"bytes":{"type":"string"}}},"v1alpha1.HTTPHeader":{"required":["name"],"properties":{"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPHeaderSource"}}},"v1alpha1.HTTPHeaderSource":{"properties":{"secretKeyRef":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.UserContainer":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"mirrorVolumeMounts":{"type":"boolean"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.Inputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Memoize":{"required":["key","cache","maxAge"],"properties":{"cache":{"$ref":"#/components/schemas/v1alpha1.Cache"},"key":{"type":"string"},"maxAge":{"type":"string"}}},"v1alpha1.Cache":{"required":["configMap"],"properties":{"configMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"}}},"v1alpha1.Metrics":{"required":["prometheus"],"properties":{"prometheus":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Prometheus"}}}},"v1alpha1.Prometheus":{"required":["name","help"],"properties":{"counter":{"$ref":"#/components/schemas/v1alpha1.Counter"},"gauge":{"$ref":"#/components/schemas/v1alpha1.Gauge"},"help":{"type":"string"},"histogram":{"$ref":"#/components/schemas/v1alpha1.Histogram"},"labels":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MetricLabel"}},"name":{"type":"string"},"when":{"type":"string"}}},"v1alpha1.Counter":{"required":["value"],"properties":{"value":{"type":"string"}}},"v1alpha1.Gauge":{"required":["value","realtime"],"properties":{"operation":{"type":"string"},"realtime":{"type":"boolean"},"value":{"type":"string"}}},"v1alpha1.Histogram":{"required":["value","buckets"],"properties":{"buckets":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Amount"}},"value":{"type":"string"}}},"v1alpha1.Amount":{},"v1alpha1.MetricLabel":{"required":["key","value"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Outputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"exitCode":{"type":"string"},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}},"result":{"type":"string"}}},"v1alpha1.Plugin":{},"v1alpha1.ResourceTemplate":{"required":["action"],"properties":{"action":{"type":"string"},"failureCondition":{"type":"string"},"flags":{"type":"array","items":{"type":"string"}},"manifest":{"type":"string"},"manifestFrom":{"$ref":"#/components/schemas/v1alpha1.ManifestFrom"},"mergeStrategy":{"type":"string"},"setOwnerReference":{"type":"boolean"},"successCondition":{"type":"string"}}},"v1alpha1.ManifestFrom":{"required":["artifact"],"properties":{"artifact":{"$ref":"#/components/schemas/v1alpha1.Artifact"}}},"v1alpha1.RetryStrategy":{"properties":{"affinity":{"$ref":"#/components/schemas/v1alpha1.RetryAffinity"},"backoff":{"$ref":"#/components/schemas/v1alpha1.Backoff"},"expression":{"type":"string"},"limit":{"$ref":"#/components/schemas/intstr.IntOrString"},"retryPolicy":{"type":"string"}}},"v1alpha1.RetryAffinity":{"properties":{"nodeAntiAffinity":{"$ref":"#/components/schemas/v1alpha1.RetryNodeAntiAffinity"}}},"v1alpha1.RetryNodeAntiAffinity":{},"v1alpha1.Backoff":{"properties":{"duration":{"type":"string"},"factor":{"$ref":"#/components/schemas/intstr.IntOrString"},"maxDuration":{"type":"string"}}},"v1alpha1.ScriptTemplate":{"description":"A single application container that you want to run within a pod.","required":["name","source"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"source":{"type":"string"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1.PodSecurityContext":{"description":"PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.","properties":{"fsGroup":{"description":"A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\n\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw ","type":"integer","format":"int64"},"fsGroupChangePolicy":{"description":"fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \"OnRootMismatch\" and \"Always\". If not specified, \"Always\" is used. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"supplementalGroups":{"description":"A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"type":"integer","format":"int64"}},"sysctls":{"description":"Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"$ref":"#/components/schemas/v1.Sysctl"}},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Sysctl":{"description":"Sysctl defines a kernel parameter to be set","required":["name","value"],"properties":{"name":{"description":"Name of a property to set","type":"string"},"value":{"description":"Value of a property to set","type":"string"}}},"v1alpha1.ParallelSteps":{},"v1alpha1.SuspendTemplate":{"properties":{"duration":{"type":"string"}}},"v1alpha1.Synchronization":{"properties":{"mutex":{"$ref":"#/components/schemas/v1alpha1.Mutex"},"semaphore":{"$ref":"#/components/schemas/v1alpha1.SemaphoreRef"}}},"v1alpha1.Mutex":{"properties":{"name":{"type":"string"},"namespace":{"type":"string"}}},"v1alpha1.SemaphoreRef":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"namespace":{"type":"string"}}},"v1.Toleration":{"description":"The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .","properties":{"effect":{"description":"Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.","type":"string"},"key":{"description":"Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.","type":"string"},"operator":{"description":"Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.","type":"string"},"tolerationSeconds":{"description":"TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.","type":"integer","format":"int64"},"value":{"description":"Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.","type":"string"}}},"v1.Volume":{"description":"Volume represents a named volume in a pod that may be accessed by any container in the pod.","required":["name"],"properties":{"awsElasticBlockStore":{"description":"awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","$ref":"#/components/schemas/v1.AWSElasticBlockStoreVolumeSource"},"azureDisk":{"description":"azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureDiskVolumeSource"},"azureFile":{"description":"azureFile represents an Azure File Service mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureFileVolumeSource"},"cephfs":{"description":"cephFS represents a Ceph FS mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.CephFSVolumeSource"},"cinder":{"description":"cinder represents a cinder volume attached and mounted on kubelets host machine. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","$ref":"#/components/schemas/v1.CinderVolumeSource"},"configMap":{"description":"configMap represents a configMap that should populate this volume","$ref":"#/components/schemas/v1.ConfigMapVolumeSource"},"csi":{"description":"csi (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers (Beta feature).","$ref":"#/components/schemas/v1.CSIVolumeSource"},"downwardAPI":{"description":"downwardAPI represents downward API about the pod that should populate this volume","$ref":"#/components/schemas/v1.DownwardAPIVolumeSource"},"emptyDir":{"description":"emptyDir represents a temporary directory that shares a pod's lifetime. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","$ref":"#/components/schemas/v1.EmptyDirVolumeSource"},"ephemeral":{"description":"ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed.\n\nUse this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity\n tracking are needed,\nc) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through\n a PersistentVolumeClaim (see EphemeralVolumeSource for more\n information on the connection between this volume type\n and PersistentVolumeClaim).\n\nUse PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod.\n\nUse CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information.\n\nA pod can use both types of ephemeral volumes and persistent volumes at the same time.","$ref":"#/components/schemas/v1.EphemeralVolumeSource"},"fc":{"description":"fc represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.","$ref":"#/components/schemas/v1.FCVolumeSource"},"flexVolume":{"description":"flexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","$ref":"#/components/schemas/v1.FlexVolumeSource"},"flocker":{"description":"flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running","$ref":"#/components/schemas/v1.FlockerVolumeSource"},"gcePersistentDisk":{"description":"gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","$ref":"#/components/schemas/v1.GCEPersistentDiskVolumeSource"},"gitRepo":{"description":"gitRepo represents a git repository at a particular revision. DEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","$ref":"#/components/schemas/v1.GitRepoVolumeSource"},"glusterfs":{"description":"glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/glusterfs/README.md","$ref":"#/components/schemas/v1.GlusterfsVolumeSource"},"hostPath":{"description":"hostPath represents a pre-existing file or directory on the host machine that is directly exposed to the container. This is generally used for system agents or other privileged things that are allowed to see the host machine. Most containers will NOT need this. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","$ref":"#/components/schemas/v1.HostPathVolumeSource"},"iscsi":{"description":"iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://examples.k8s.io/volumes/iscsi/README.md","$ref":"#/components/schemas/v1.ISCSIVolumeSource"},"name":{"description":"name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"nfs":{"description":"nfs represents an NFS mount on the host that shares a pod's lifetime More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","$ref":"#/components/schemas/v1.NFSVolumeSource"},"persistentVolumeClaim":{"description":"persistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimVolumeSource"},"photonPersistentDisk":{"description":"photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PhotonPersistentDiskVolumeSource"},"portworxVolume":{"description":"portworxVolume represents a portworx volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PortworxVolumeSource"},"projected":{"description":"projected items for all in one resources secrets, configmaps, and downward API","$ref":"#/components/schemas/v1.ProjectedVolumeSource"},"quobyte":{"description":"quobyte represents a Quobyte mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.QuobyteVolumeSource"},"rbd":{"description":"rbd represents a Rados Block Device mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/rbd/README.md","$ref":"#/components/schemas/v1.RBDVolumeSource"},"scaleIO":{"description":"scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.ScaleIOVolumeSource"},"secret":{"description":"secret represents a secret that should populate this volume. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","$ref":"#/components/schemas/v1.SecretVolumeSource"},"storageos":{"description":"storageOS represents a StorageOS volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.StorageOSVolumeSource"},"vsphereVolume":{"description":"vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.VsphereVirtualDiskVolumeSource"}}},"v1.AWSElasticBlockStoreVolumeSource":{"description":"Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).","type":"integer","format":"int32"},"readOnly":{"description":"readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"boolean"},"volumeID":{"description":"volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"}}},"v1.AzureDiskVolumeSource":{"description":"AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","required":["diskName","diskURI"],"properties":{"cachingMode":{"description":"cachingMode is the Host Caching mode: None, Read Only, Read Write.","type":"string"},"diskName":{"description":"diskName is the Name of the data disk in the blob storage","type":"string"},"diskURI":{"description":"diskURI is the URI of data disk in the blob storage","type":"string"},"fsType":{"description":"fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"kind":{"description":"kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"}}},"v1.AzureFileVolumeSource":{"description":"AzureFile represents an Azure File Service mount on the host and bind mount to the pod.","required":["secretName","shareName"],"properties":{"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretName":{"description":"secretName is the name of secret that contains Azure Storage Account Name and Key","type":"string"},"shareName":{"description":"shareName is the azure share Name","type":"string"}}},"v1.CephFSVolumeSource":{"description":"Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.","required":["monitors"],"properties":{"monitors":{"description":"monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"path":{"description":"path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /","type":"string"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"boolean"},"secretFile":{"description":"secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"},"secretRef":{"description":"secretRef is Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"}}},"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}},"v1.CinderVolumeSource":{"description":"Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"boolean"},"secretRef":{"description":"secretRef is optional: points to a secret object containing parameters used to connect to OpenStack.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeID":{"description":"volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"}}},"v1.ConfigMapVolumeSource":{"description":"Adapts a ConfigMap into a volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.KeyToPath":{"description":"Maps a string key to a path within a volume.","required":["key","path"],"properties":{"key":{"description":"key is the key to project.","type":"string"},"mode":{"description":"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.","type":"string"}}},"v1.CSIVolumeSource":{"description":"Represents a source location of a volume to mount, managed by an external CSI driver","required":["driver"],"properties":{"driver":{"description":"driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.","type":"string"},"fsType":{"description":"fsType to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.","type":"string"},"nodePublishSecretRef":{"description":"nodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secret references are passed.","$ref":"#/components/schemas/v1.LocalObjectReference"},"readOnly":{"description":"readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).","type":"boolean"},"volumeAttributes":{"description":"volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.","type":"object","additionalProperties":{"type":"string"}}}},"v1.DownwardAPIVolumeSource":{"description":"DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"Items is a list of downward API volume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.DownwardAPIVolumeFile":{"description":"DownwardAPIVolumeFile represents information to create the file containing the pod field","required":["path"],"properties":{"fieldRef":{"description":"Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"mode":{"description":"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'","type":"string"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"}}},"v1.EmptyDirVolumeSource":{"description":"Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.","properties":{"medium":{"description":"medium represents what type of storage medium should back this directory. The default is \"\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","type":"string"},"sizeLimit":{"description":"sizeLimit is the total amount of local storage required for this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. The default is nil which means that the limit is undefined. More info: http://kubernetes.io/docs/user-guide/volumes#emptydir","$ref":"#/components/schemas/resource.Quantity"}}},"v1.EphemeralVolumeSource":{"description":"Represents an ephemeral volume that is handled by a normal storage driver.","properties":{"volumeClaimTemplate":{"description":"Will be used to create a stand-alone PVC to provision the volume. The pod in which this EphemeralVolumeSource is embedded will be the owner of the PVC, i.e. the PVC will be deleted together with the pod. The name of the PVC will be `-` where `` is the name from the `PodSpec.Volumes` array entry. Pod validation will reject the pod if the concatenated name is not valid for a PVC (for example, too long).\n\nAn existing PVC with that name that is not owned by the pod will *not* be used for the pod to avoid using an unrelated volume by mistake. Starting the pod is then blocked until the unrelated PVC is removed. If such a pre-created PVC is meant to be used by the pod, the PVC has to updated with an owner reference to the pod once the pod exists. Normally this should not be necessary, but it may be useful when manually reconstructing a broken cluster.\n\nThis field is read-only and no changes will be made by Kubernetes to the PVC after it has been created.\n\nRequired, must not be nil.","$ref":"#/components/schemas/v1.PersistentVolumeClaimTemplate"}}},"v1.PersistentVolumeClaimTemplate":{"description":"PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.","required":["spec"],"properties":{"metadata":{"description":"May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"The specification for the PersistentVolumeClaim. The entire content is copied unchanged into the PVC that gets created from this template. The same fields as in a PersistentVolumeClaim are also valid here.","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"}}},"v1.ObjectMeta":{"description":"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.","properties":{"annotations":{"description":"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations","type":"object","additionalProperties":{"type":"string"}},"clusterName":{"description":"Deprecated: ClusterName is a legacy field that was always cleared by the system and never used; it will be removed completely in 1.25.\n\nThe name in the go struct is changed to help clients detect accidental use.","type":"string"},"creationTimestamp":{"description":"CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"deletionGracePeriodSeconds":{"description":"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.","type":"integer","format":"int64"},"deletionTimestamp":{"description":"DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"finalizers":{"description":"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.","type":"array","items":{"type":"string"}},"generateName":{"description":"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency","type":"string"},"generation":{"description":"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.","type":"integer","format":"int64"},"labels":{"description":"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels","type":"object","additionalProperties":{"type":"string"}},"managedFields":{"description":"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.","type":"array","items":{"$ref":"#/components/schemas/v1.ManagedFieldsEntry"}},"name":{"description":"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"namespace":{"description":"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces","type":"string"},"ownerReferences":{"description":"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.","type":"array","items":{"$ref":"#/components/schemas/v1.OwnerReference"}},"resourceVersion":{"description":"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency","type":"string"},"selfLink":{"description":"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.","type":"string"},"uid":{"description":"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}},"v1.ManagedFieldsEntry":{"description":"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.","properties":{"apiVersion":{"description":"APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.","type":"string"},"fieldsType":{"description":"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"","type":"string"},"fieldsV1":{"description":"FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type.","$ref":"#/components/schemas/v1.FieldsV1"},"manager":{"description":"Manager is an identifier of the workflow managing these fields.","type":"string"},"operation":{"description":"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.","type":"string"},"subresource":{"description":"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.","type":"string"},"time":{"description":"Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over.","$ref":"#/components/schemas/v1.Time"}}},"v1.FieldsV1":{"description":"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff"},"v1.OwnerReference":{"description":"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.","required":["apiVersion","kind","name","uid"],"properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"blockOwnerDeletion":{"description":"If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.","type":"boolean"},"controller":{"description":"If true, this reference points to the managing controller.","type":"boolean"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"uid":{"description":"UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.PersistentVolumeClaimSpec":{"description":"PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes","properties":{"accessModes":{"description":"accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"dataSource":{"description":"dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"dataSourceRef":{"description":"dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"resources":{"description":"resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources","$ref":"#/components/schemas/v1.ResourceRequirements"},"selector":{"description":"selector is a label query over volumes to consider for binding.","$ref":"#/components/schemas/v1.LabelSelector"},"storageClassName":{"description":"storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1","type":"string"},"volumeMode":{"description":"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.","type":"string"},"volumeName":{"description":"volumeName is the binding reference to the PersistentVolume backing this claim.","type":"string"}}},"v1.TypedLocalObjectReference":{"description":"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.","required":["apiGroup","kind","name"],"properties":{"apiGroup":{"description":"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.","type":"string"},"kind":{"description":"Kind is the type of resource being referenced","type":"string"},"name":{"description":"Name is the name of resource being referenced","type":"string"}}},"v1.FCVolumeSource":{"description":"Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"lun":{"description":"lun is Optional: FC target lun number","type":"integer","format":"int32"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"targetWWNs":{"description":"targetWWNs is Optional: FC target worldwide names (WWNs)","type":"array","items":{"type":"string"}},"wwids":{"description":"wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.","type":"array","items":{"type":"string"}}}},"v1.FlexVolumeSource":{"description":"FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","required":["driver"],"properties":{"driver":{"description":"driver is the name of the driver to use for this volume.","type":"string"},"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.","type":"string"},"options":{"description":"options is Optional: this field holds extra command options if any.","type":"object","additionalProperties":{"type":"string"}},"readOnly":{"description":"readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef is Optional: secretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts.","$ref":"#/components/schemas/v1.LocalObjectReference"}}},"v1.FlockerVolumeSource":{"description":"Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.","properties":{"datasetName":{"description":"datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated","type":"string"},"datasetUUID":{"description":"datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset","type":"string"}}},"v1.GCEPersistentDiskVolumeSource":{"description":"Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.","required":["pdName"],"properties":{"fsType":{"description":"fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"integer","format":"int32"},"pdName":{"description":"pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"boolean"}}},"v1.GitRepoVolumeSource":{"description":"Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","required":["repository"],"properties":{"directory":{"description":"directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.","type":"string"},"repository":{"description":"repository is the URL","type":"string"},"revision":{"description":"revision is the commit hash for the specified revision.","type":"string"}}},"v1.GlusterfsVolumeSource":{"description":"Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.","required":["endpoints","path"],"properties":{"endpoints":{"description":"endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"path":{"description":"path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"readOnly":{"description":"readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"boolean"}}},"v1.HostPathVolumeSource":{"description":"Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.","required":["path"],"properties":{"path":{"description":"path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"},"type":{"description":"type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"}}},"v1.ISCSIVolumeSource":{"description":"Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.","required":["targetPortal","iqn","lun"],"properties":{"chapAuthDiscovery":{"description":"chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication","type":"boolean"},"chapAuthSession":{"description":"chapAuthSession defines whether support iSCSI Session CHAP authentication","type":"boolean"},"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi","type":"string"},"initiatorName":{"description":"initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.","type":"string"},"iqn":{"description":"iqn is the target iSCSI Qualified Name.","type":"string"},"iscsiInterface":{"description":"iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).","type":"string"},"lun":{"description":"lun represents iSCSI Target Lun number.","type":"integer","format":"int32"},"portals":{"description":"portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"array","items":{"type":"string"}},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.","type":"boolean"},"secretRef":{"description":"secretRef is the CHAP Secret for iSCSI target and initiator authentication","$ref":"#/components/schemas/v1.LocalObjectReference"},"targetPortal":{"description":"targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"string"}}},"v1.NFSVolumeSource":{"description":"Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.","required":["server","path"],"properties":{"path":{"description":"path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"},"readOnly":{"description":"readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"boolean"},"server":{"description":"server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"}}},"v1.PersistentVolumeClaimVolumeSource":{"description":"PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).","required":["claimName"],"properties":{"claimName":{"description":"claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","type":"string"},"readOnly":{"description":"readOnly Will force the ReadOnly setting in VolumeMounts. Default false.","type":"boolean"}}},"v1.PhotonPersistentDiskVolumeSource":{"description":"Represents a Photon Controller persistent disk resource.","required":["pdID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"pdID":{"description":"pdID is the ID that identifies Photon Controller persistent disk","type":"string"}}},"v1.PortworxVolumeSource":{"description":"PortworxVolumeSource represents a Portworx volume resource.","required":["volumeID"],"properties":{"fsType":{"description":"fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"volumeID":{"description":"volumeID uniquely identifies a Portworx volume","type":"string"}}},"v1.ProjectedVolumeSource":{"description":"Represents a projected volume source","required":["sources"],"properties":{"defaultMode":{"description":"defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"sources":{"description":"sources is the list of volume projections","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeProjection"}}}},"v1.VolumeProjection":{"description":"Projection that may be projected along with other supported volume types","properties":{"configMap":{"description":"configMap information about the configMap data to project","$ref":"#/components/schemas/v1.ConfigMapProjection"},"downwardAPI":{"description":"downwardAPI information about the downwardAPI data to project","$ref":"#/components/schemas/v1.DownwardAPIProjection"},"secret":{"description":"secret information about the secret data to project","$ref":"#/components/schemas/v1.SecretProjection"},"serviceAccountToken":{"description":"serviceAccountToken is information about the serviceAccountToken data to project","$ref":"#/components/schemas/v1.ServiceAccountTokenProjection"}}},"v1.ConfigMapProjection":{"description":"Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.DownwardAPIProjection":{"description":"Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.","properties":{"items":{"description":"Items is a list of DownwardAPIVolume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.SecretProjection":{"description":"Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional field specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.ServiceAccountTokenProjection":{"description":"ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).","required":["path"],"properties":{"audience":{"description":"audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.","type":"string"},"expirationSeconds":{"description":"expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.","type":"integer","format":"int64"},"path":{"description":"path is the path relative to the mount point of the file to project the token into.","type":"string"}}},"v1.QuobyteVolumeSource":{"description":"Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.","required":["registry","volume"],"properties":{"group":{"description":"group to map volume access to Default is no group","type":"string"},"readOnly":{"description":"readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.","type":"boolean"},"registry":{"description":"registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes","type":"string"},"tenant":{"description":"tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin","type":"string"},"user":{"description":"user to map volume access to Defaults to serivceaccount user","type":"string"},"volume":{"description":"volume is a string that references an already created Quobyte volume by name.","type":"string"}}},"v1.RBDVolumeSource":{"description":"Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.","required":["monitors","image"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd","type":"string"},"image":{"description":"image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"keyring":{"description":"keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"monitors":{"description":"monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"pool":{"description":"pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"boolean"},"secretRef":{"description":"secretRef is name of the authentication secret for RBDUser. If provided overrides keyring. Default is nil. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"}}},"v1.ScaleIOVolumeSource":{"description":"ScaleIOVolumeSource represents a persistent ScaleIO volume","required":["gateway","system","secretRef"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\".","type":"string"},"gateway":{"description":"gateway is the host address of the ScaleIO API Gateway.","type":"string"},"protectionDomain":{"description":"protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef references to the secret for ScaleIO user and other sensitive information. If this is not provided, Login operation will fail.","$ref":"#/components/schemas/v1.LocalObjectReference"},"sslEnabled":{"description":"sslEnabled Flag enable/disable SSL communication with Gateway, default false","type":"boolean"},"storageMode":{"description":"storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.","type":"string"},"storagePool":{"description":"storagePool is the ScaleIO Storage Pool associated with the protection domain.","type":"string"},"system":{"description":"system is the name of the storage system as configured in ScaleIO.","type":"string"},"volumeName":{"description":"volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.","type":"string"}}},"v1.SecretVolumeSource":{"description":"Adapts a Secret into a volume.\n\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"optional":{"description":"optional field specify whether the Secret or its keys must be defined","type":"boolean"},"secretName":{"description":"secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","type":"string"}}},"v1.StorageOSVolumeSource":{"description":"Represents a StorageOS persistent volume resource.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeName":{"description":"volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.","type":"string"},"volumeNamespace":{"description":"volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.","type":"string"}}},"v1.VsphereVirtualDiskVolumeSource":{"description":"Represents a vSphere volume resource.","required":["volumePath"],"properties":{"fsType":{"description":"fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"storagePolicyID":{"description":"storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.","type":"string"},"storagePolicyName":{"description":"storagePolicyName is the storage Policy Based Management (SPBM) profile name.","type":"string"},"volumePath":{"description":"volumePath is the path that identifies vSphere volume vmdk","type":"string"}}}}}} ``` ## The v1alpha1.DAGTemplate object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.DAGTemplate":{"required":["tasks"],"properties":{"failFast":{"type":"boolean"},"target":{"type":"string"},"tasks":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.DAGTask"}}}},"v1alpha1.DAGTask":{"required":["name"],"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"continueOn":{"$ref":"#/components/schemas/v1alpha1.ContinueOn"},"dependencies":{"type":"array","items":{"type":"string"}},"depends":{"type":"string"},"hooks":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LifecycleHook"}},"inline":{"$ref":"#/components/schemas/v1alpha1.Template"},"name":{"type":"string"},"onExit":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"},"when":{"type":"string"},"withItems":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Item"}},"withParam":{"type":"string"},"withSequence":{"$ref":"#/components/schemas/v1alpha1.Sequence"}}},"v1alpha1.Arguments":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Artifact":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.Parameter":{"required":["name"],"properties":{"default":{"type":"string"},"description":{"type":"string"},"enum":{"type":"array","items":{"type":"string"}},"globalName":{"type":"string"},"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.ValueFrom"}}},"v1alpha1.ValueFrom":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"default":{"type":"string"},"event":{"type":"string"},"expression":{"type":"string"},"jqFilter":{"type":"string"},"jsonPath":{"type":"string"},"parameter":{"type":"string"},"path":{"type":"string"},"supplied":{"$ref":"#/components/schemas/v1alpha1.SuppliedValueFrom"}}},"v1alpha1.SuppliedValueFrom":{},"v1alpha1.ContinueOn":{"properties":{"error":{"type":"boolean"},"failed":{"type":"boolean"}}},"v1alpha1.LifecycleHook":{"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"expression":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"}}},"v1alpha1.TemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"},"template":{"type":"string"}}},"v1alpha1.Template":{"properties":{"activeDeadlineSeconds":{"$ref":"#/components/schemas/intstr.IntOrString"},"affinity":{"$ref":"#/components/schemas/v1.Affinity"},"archiveLocation":{"$ref":"#/components/schemas/v1alpha1.ArtifactLocation"},"automountServiceAccountToken":{"type":"boolean"},"container":{"$ref":"#/components/schemas/v1.Container"},"containerSet":{"$ref":"#/components/schemas/v1alpha1.ContainerSetTemplate"},"daemon":{"type":"boolean"},"dag":{"$ref":"#/components/schemas/v1alpha1.DAGTemplate"},"data":{"$ref":"#/components/schemas/v1alpha1.Data"},"executor":{"$ref":"#/components/schemas/v1alpha1.ExecutorConfig"},"failFast":{"type":"boolean"},"hostAliases":{"type":"array","items":{"$ref":"#/components/schemas/v1.HostAlias"}},"http":{"$ref":"#/components/schemas/v1alpha1.HTTP"},"initContainers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"inputs":{"$ref":"#/components/schemas/v1alpha1.Inputs"},"memoize":{"$ref":"#/components/schemas/v1alpha1.Memoize"},"metadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"metrics":{"$ref":"#/components/schemas/v1alpha1.Metrics"},"name":{"type":"string"},"nodeSelector":{"type":"object","additionalProperties":{"type":"string"}},"outputs":{"$ref":"#/components/schemas/v1alpha1.Outputs"},"parallelism":{"type":"integer","format":"int64"},"plugin":{"$ref":"#/components/schemas/v1alpha1.Plugin"},"podSpecPatch":{"type":"string"},"priority":{"type":"integer","format":"int32"},"priorityClassName":{"type":"string"},"resource":{"$ref":"#/components/schemas/v1alpha1.ResourceTemplate"},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.RetryStrategy"},"schedulerName":{"type":"string"},"script":{"$ref":"#/components/schemas/v1alpha1.ScriptTemplate"},"securityContext":{"$ref":"#/components/schemas/v1.PodSecurityContext"},"serviceAccountName":{"type":"string"},"sidecars":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"steps":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ParallelSteps"}},"suspend":{"$ref":"#/components/schemas/v1alpha1.SuspendTemplate"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.Synchronization"},"timeout":{"type":"string"},"tolerations":{"type":"array","items":{"$ref":"#/components/schemas/v1.Toleration"}},"volumes":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}},"v1.Affinity":{"description":"Affinity is a group of affinity scheduling rules.","properties":{"nodeAffinity":{"description":"Describes node affinity scheduling rules for the pod.","$ref":"#/components/schemas/v1.NodeAffinity"},"podAffinity":{"description":"Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAffinity"},"podAntiAffinity":{"description":"Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAntiAffinity"}}},"v1.NodeAffinity":{"description":"Node affinity is a group of node affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.PreferredSchedulingTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.","$ref":"#/components/schemas/v1.NodeSelector"}}},"v1.PreferredSchedulingTerm":{"description":"An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).","required":["weight","preference"],"properties":{"preference":{"description":"A node selector term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.NodeSelectorTerm"},"weight":{"description":"Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.NodeSelectorTerm":{"description":"A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.","properties":{"matchExpressions":{"description":"A list of node selector requirements by node's labels.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}},"matchFields":{"description":"A list of node selector requirements by node's fields.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}}}},"v1.NodeSelectorRequirement":{"description":"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"The label key that the selector applies to.","type":"string"},"operator":{"description":"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.","type":"string"},"values":{"description":"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.NodeSelector":{"description":"A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.","required":["nodeSelectorTerms"],"properties":{"nodeSelectorTerms":{"description":"Required. A list of node selector terms. The terms are ORed.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorTerm"}}}},"v1.PodAffinity":{"description":"Pod affinity is a group of inter pod affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1.WeightedPodAffinityTerm":{"description":"The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)","required":["weight","podAffinityTerm"],"properties":{"podAffinityTerm":{"description":"Required. A pod affinity term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.PodAffinityTerm"},"weight":{"description":"weight associated with matching the corresponding podAffinityTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.PodAffinityTerm":{"description":"Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running","required":["topologyKey"],"properties":{"labelSelector":{"description":"A label query over a set of resources, in this case pods.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaceSelector":{"description":"A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means \"this pod's namespace\". An empty selector ({}) matches all namespaces.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaces":{"description":"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".","type":"array","items":{"type":"string"}},"topologyKey":{"description":"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.","type":"string"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.PodAntiAffinity":{"description":"Pod anti affinity is a group of inter pod anti affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1alpha1.ArtifactLocation":{"properties":{"archiveLogs":{"type":"boolean"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"}}},"v1.Container":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1.EnvVar":{"description":"EnvVar represents an environment variable present in a Container.","required":["name"],"properties":{"name":{"description":"Name of the environment variable. Must be a C_IDENTIFIER.","type":"string"},"value":{"description":"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".","type":"string"},"valueFrom":{"description":"Source for the environment variable's value. Cannot be used if value is not empty.","$ref":"#/components/schemas/v1.EnvVarSource"}}},"v1.EnvVarSource":{"description":"EnvVarSource represents a source for the value of an EnvVar.","properties":{"configMapKeyRef":{"description":"Selects a key of a ConfigMap.","$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"fieldRef":{"description":"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"},"secretKeyRef":{"description":"Selects a key of a secret in the pod's namespace","$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.EnvFromSource":{"description":"EnvFromSource represents the source of a set of ConfigMaps","properties":{"configMapRef":{"description":"The ConfigMap to select from","$ref":"#/components/schemas/v1.ConfigMapEnvSource"},"prefix":{"description":"An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.","type":"string"},"secretRef":{"description":"The Secret to select from","$ref":"#/components/schemas/v1.SecretEnvSource"}}},"v1.ConfigMapEnvSource":{"description":"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap must be defined","type":"boolean"}}},"v1.SecretEnvSource":{"description":"SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret must be defined","type":"boolean"}}},"v1.Lifecycle":{"description":"Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.","properties":{"postStart":{"description":"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"},"preStop":{"description":"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"}}},"v1.LifecycleHandler":{"description":"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"tcpSocket":{"description":"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.","$ref":"#/components/schemas/v1.TCPSocketAction"}}},"v1.ExecAction":{"description":"ExecAction describes a \"run in container\" action.","properties":{"command":{"description":"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.","type":"array","items":{"type":"string"}}}},"v1.HTTPGetAction":{"description":"HTTPGetAction describes an action based on HTTP Get requests.","required":["port"],"properties":{"host":{"description":"Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.","type":"string"},"httpHeaders":{"description":"Custom headers to set in the request. HTTP allows repeated headers.","type":"array","items":{"$ref":"#/components/schemas/v1.HTTPHeader"}},"path":{"description":"Path to access on the HTTP server.","type":"string"},"port":{"description":"Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"},"scheme":{"description":"Scheme to use for connecting to the host. Defaults to HTTP.","type":"string"}}},"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}},"v1.TCPSocketAction":{"description":"TCPSocketAction describes an action based on opening a socket","required":["port"],"properties":{"host":{"description":"Optional: Host name to connect to, defaults to the pod IP.","type":"string"},"port":{"description":"Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"}}},"v1.Probe":{"description":"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"failureThreshold":{"description":"Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.","type":"integer","format":"int32"},"grpc":{"description":"GRPC specifies an action involving a GRPC port. This is a beta field and requires enabling GRPCContainerProbe feature gate.","$ref":"#/components/schemas/v1.GRPCAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"initialDelaySeconds":{"description":"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"},"periodSeconds":{"description":"How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.","type":"integer","format":"int32"},"successThreshold":{"description":"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.","type":"integer","format":"int32"},"tcpSocket":{"description":"TCPSocket specifies an action involving a TCP port.","$ref":"#/components/schemas/v1.TCPSocketAction"},"terminationGracePeriodSeconds":{"description":"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.","type":"integer","format":"int64"},"timeoutSeconds":{"description":"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"}}},"v1.GRPCAction":{"required":["port","service"],"properties":{"port":{"description":"Port number of the gRPC service. Number must be in the range 1 to 65535.","type":"integer","format":"int32"},"service":{"description":"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.","type":"string"}}},"v1.ContainerPort":{"description":"ContainerPort represents a network port in a single container.","required":["containerPort"],"properties":{"containerPort":{"description":"Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.","type":"integer","format":"int32"},"hostIP":{"description":"What host IP to bind the external port to.","type":"string"},"hostPort":{"description":"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.","type":"integer","format":"int32"},"name":{"description":"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.","type":"string"},"protocol":{"description":"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"v1.SecurityContext":{"description":"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.","properties":{"allowPrivilegeEscalation":{"description":"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"capabilities":{"description":"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.Capabilities"},"privileged":{"description":"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"procMount":{"description":"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"readOnlyRootFilesystem":{"description":"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Capabilities":{"description":"Adds and removes POSIX capabilities from running containers.","properties":{"add":{"description":"Added capabilities","type":"array","items":{"type":"string"}},"drop":{"description":"Removed capabilities","type":"array","items":{"type":"string"}}}},"v1.SELinuxOptions":{"description":"SELinuxOptions are the labels to be applied to the container","properties":{"level":{"description":"Level is SELinux level label that applies to the container.","type":"string"},"role":{"description":"Role is a SELinux role label that applies to the container.","type":"string"},"type":{"description":"Type is a SELinux type label that applies to the container.","type":"string"},"user":{"description":"User is a SELinux user label that applies to the container.","type":"string"}}},"v1.SeccompProfile":{"description":"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.","required":["type"],"properties":{"localhostProfile":{"description":"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is \"Localhost\".","type":"string"},"type":{"description":"type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.","type":"string"}}},"v1.WindowsSecurityContextOptions":{"description":"WindowsSecurityContextOptions contain Windows-specific options and credentials.","properties":{"gmsaCredentialSpec":{"description":"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.","type":"string"},"gmsaCredentialSpecName":{"description":"GMSACredentialSpecName is the name of the GMSA credential spec to use.","type":"string"},"hostProcess":{"description":"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.","type":"boolean"},"runAsUserName":{"description":"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"string"}}},"v1.VolumeDevice":{"description":"volumeDevice describes a mapping of a raw block device within a container.","required":["name","devicePath"],"properties":{"devicePath":{"description":"devicePath is the path inside of the container that the device will be mapped to.","type":"string"},"name":{"description":"name must match the name of a persistentVolumeClaim in the pod","type":"string"}}},"v1.VolumeMount":{"description":"VolumeMount describes a mounting of a Volume within a container.","required":["name","mountPath"],"properties":{"mountPath":{"description":"Path within the container at which the volume should be mounted. Must not contain ':'.","type":"string"},"mountPropagation":{"description":"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10.","type":"string"},"name":{"description":"This must match the Name of a Volume.","type":"string"},"readOnly":{"description":"Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.","type":"boolean"},"subPath":{"description":"Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).","type":"string"},"subPathExpr":{"description":"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.","type":"string"}}},"v1alpha1.ContainerSetTemplate":{"required":["containers"],"properties":{"containers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ContainerNode"}},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.ContainerSetRetryStrategy"},"volumeMounts":{"type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}}}},"v1alpha1.ContainerNode":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"dependencies":{"type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.ContainerSetRetryStrategy":{"required":["retries"],"properties":{"duration":{"type":"string"},"retries":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"v1alpha1.Data":{"required":["source","transformation"],"properties":{"source":{"$ref":"#/components/schemas/v1alpha1.DataSource"},"transformation":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.TransformationStep"}}}},"v1alpha1.DataSource":{"properties":{"artifactPaths":{"$ref":"#/components/schemas/v1alpha1.ArtifactPaths"}}},"v1alpha1.ArtifactPaths":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.TransformationStep":{"required":["expression"],"properties":{"expression":{"type":"string"}}},"v1alpha1.ExecutorConfig":{"properties":{"serviceAccountName":{"type":"string"}}},"v1.HostAlias":{"description":"HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.","properties":{"hostnames":{"description":"Hostnames for the above IP address.","type":"array","items":{"type":"string"}},"ip":{"description":"IP address of the host file entry.","type":"string"}}},"v1alpha1.HTTP":{"required":["url"],"properties":{"body":{"type":"string"},"bodyFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPBodySource"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.HTTPHeader"}},"insecureSkipVerify":{"type":"boolean"},"method":{"type":"string"},"successCondition":{"type":"string"},"timeoutSeconds":{"type":"integer","format":"int64"},"url":{"type":"string"}}},"v1alpha1.HTTPBodySource":{"properties":{"bytes":{"type":"string"}}},"v1alpha1.HTTPHeader":{"required":["name"],"properties":{"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPHeaderSource"}}},"v1alpha1.HTTPHeaderSource":{"properties":{"secretKeyRef":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.UserContainer":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"mirrorVolumeMounts":{"type":"boolean"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.Inputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Memoize":{"required":["key","cache","maxAge"],"properties":{"cache":{"$ref":"#/components/schemas/v1alpha1.Cache"},"key":{"type":"string"},"maxAge":{"type":"string"}}},"v1alpha1.Cache":{"required":["configMap"],"properties":{"configMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"}}},"v1alpha1.Metrics":{"required":["prometheus"],"properties":{"prometheus":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Prometheus"}}}},"v1alpha1.Prometheus":{"required":["name","help"],"properties":{"counter":{"$ref":"#/components/schemas/v1alpha1.Counter"},"gauge":{"$ref":"#/components/schemas/v1alpha1.Gauge"},"help":{"type":"string"},"histogram":{"$ref":"#/components/schemas/v1alpha1.Histogram"},"labels":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MetricLabel"}},"name":{"type":"string"},"when":{"type":"string"}}},"v1alpha1.Counter":{"required":["value"],"properties":{"value":{"type":"string"}}},"v1alpha1.Gauge":{"required":["value","realtime"],"properties":{"operation":{"type":"string"},"realtime":{"type":"boolean"},"value":{"type":"string"}}},"v1alpha1.Histogram":{"required":["value","buckets"],"properties":{"buckets":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Amount"}},"value":{"type":"string"}}},"v1alpha1.Amount":{},"v1alpha1.MetricLabel":{"required":["key","value"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Outputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"exitCode":{"type":"string"},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}},"result":{"type":"string"}}},"v1alpha1.Plugin":{},"v1alpha1.ResourceTemplate":{"required":["action"],"properties":{"action":{"type":"string"},"failureCondition":{"type":"string"},"flags":{"type":"array","items":{"type":"string"}},"manifest":{"type":"string"},"manifestFrom":{"$ref":"#/components/schemas/v1alpha1.ManifestFrom"},"mergeStrategy":{"type":"string"},"setOwnerReference":{"type":"boolean"},"successCondition":{"type":"string"}}},"v1alpha1.ManifestFrom":{"required":["artifact"],"properties":{"artifact":{"$ref":"#/components/schemas/v1alpha1.Artifact"}}},"v1alpha1.RetryStrategy":{"properties":{"affinity":{"$ref":"#/components/schemas/v1alpha1.RetryAffinity"},"backoff":{"$ref":"#/components/schemas/v1alpha1.Backoff"},"expression":{"type":"string"},"limit":{"$ref":"#/components/schemas/intstr.IntOrString"},"retryPolicy":{"type":"string"}}},"v1alpha1.RetryAffinity":{"properties":{"nodeAntiAffinity":{"$ref":"#/components/schemas/v1alpha1.RetryNodeAntiAffinity"}}},"v1alpha1.RetryNodeAntiAffinity":{},"v1alpha1.Backoff":{"properties":{"duration":{"type":"string"},"factor":{"$ref":"#/components/schemas/intstr.IntOrString"},"maxDuration":{"type":"string"}}},"v1alpha1.ScriptTemplate":{"description":"A single application container that you want to run within a pod.","required":["name","source"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"source":{"type":"string"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1.PodSecurityContext":{"description":"PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.","properties":{"fsGroup":{"description":"A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\n\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw ","type":"integer","format":"int64"},"fsGroupChangePolicy":{"description":"fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \"OnRootMismatch\" and \"Always\". If not specified, \"Always\" is used. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"supplementalGroups":{"description":"A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"type":"integer","format":"int64"}},"sysctls":{"description":"Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"$ref":"#/components/schemas/v1.Sysctl"}},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Sysctl":{"description":"Sysctl defines a kernel parameter to be set","required":["name","value"],"properties":{"name":{"description":"Name of a property to set","type":"string"},"value":{"description":"Value of a property to set","type":"string"}}},"v1alpha1.ParallelSteps":{},"v1alpha1.SuspendTemplate":{"properties":{"duration":{"type":"string"}}},"v1alpha1.Synchronization":{"properties":{"mutex":{"$ref":"#/components/schemas/v1alpha1.Mutex"},"semaphore":{"$ref":"#/components/schemas/v1alpha1.SemaphoreRef"}}},"v1alpha1.Mutex":{"properties":{"name":{"type":"string"},"namespace":{"type":"string"}}},"v1alpha1.SemaphoreRef":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"namespace":{"type":"string"}}},"v1.Toleration":{"description":"The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .","properties":{"effect":{"description":"Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.","type":"string"},"key":{"description":"Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.","type":"string"},"operator":{"description":"Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.","type":"string"},"tolerationSeconds":{"description":"TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.","type":"integer","format":"int64"},"value":{"description":"Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.","type":"string"}}},"v1.Volume":{"description":"Volume represents a named volume in a pod that may be accessed by any container in the pod.","required":["name"],"properties":{"awsElasticBlockStore":{"description":"awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","$ref":"#/components/schemas/v1.AWSElasticBlockStoreVolumeSource"},"azureDisk":{"description":"azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureDiskVolumeSource"},"azureFile":{"description":"azureFile represents an Azure File Service mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureFileVolumeSource"},"cephfs":{"description":"cephFS represents a Ceph FS mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.CephFSVolumeSource"},"cinder":{"description":"cinder represents a cinder volume attached and mounted on kubelets host machine. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","$ref":"#/components/schemas/v1.CinderVolumeSource"},"configMap":{"description":"configMap represents a configMap that should populate this volume","$ref":"#/components/schemas/v1.ConfigMapVolumeSource"},"csi":{"description":"csi (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers (Beta feature).","$ref":"#/components/schemas/v1.CSIVolumeSource"},"downwardAPI":{"description":"downwardAPI represents downward API about the pod that should populate this volume","$ref":"#/components/schemas/v1.DownwardAPIVolumeSource"},"emptyDir":{"description":"emptyDir represents a temporary directory that shares a pod's lifetime. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","$ref":"#/components/schemas/v1.EmptyDirVolumeSource"},"ephemeral":{"description":"ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed.\n\nUse this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity\n tracking are needed,\nc) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through\n a PersistentVolumeClaim (see EphemeralVolumeSource for more\n information on the connection between this volume type\n and PersistentVolumeClaim).\n\nUse PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod.\n\nUse CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information.\n\nA pod can use both types of ephemeral volumes and persistent volumes at the same time.","$ref":"#/components/schemas/v1.EphemeralVolumeSource"},"fc":{"description":"fc represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.","$ref":"#/components/schemas/v1.FCVolumeSource"},"flexVolume":{"description":"flexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","$ref":"#/components/schemas/v1.FlexVolumeSource"},"flocker":{"description":"flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running","$ref":"#/components/schemas/v1.FlockerVolumeSource"},"gcePersistentDisk":{"description":"gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","$ref":"#/components/schemas/v1.GCEPersistentDiskVolumeSource"},"gitRepo":{"description":"gitRepo represents a git repository at a particular revision. DEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","$ref":"#/components/schemas/v1.GitRepoVolumeSource"},"glusterfs":{"description":"glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/glusterfs/README.md","$ref":"#/components/schemas/v1.GlusterfsVolumeSource"},"hostPath":{"description":"hostPath represents a pre-existing file or directory on the host machine that is directly exposed to the container. This is generally used for system agents or other privileged things that are allowed to see the host machine. Most containers will NOT need this. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","$ref":"#/components/schemas/v1.HostPathVolumeSource"},"iscsi":{"description":"iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://examples.k8s.io/volumes/iscsi/README.md","$ref":"#/components/schemas/v1.ISCSIVolumeSource"},"name":{"description":"name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"nfs":{"description":"nfs represents an NFS mount on the host that shares a pod's lifetime More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","$ref":"#/components/schemas/v1.NFSVolumeSource"},"persistentVolumeClaim":{"description":"persistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimVolumeSource"},"photonPersistentDisk":{"description":"photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PhotonPersistentDiskVolumeSource"},"portworxVolume":{"description":"portworxVolume represents a portworx volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PortworxVolumeSource"},"projected":{"description":"projected items for all in one resources secrets, configmaps, and downward API","$ref":"#/components/schemas/v1.ProjectedVolumeSource"},"quobyte":{"description":"quobyte represents a Quobyte mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.QuobyteVolumeSource"},"rbd":{"description":"rbd represents a Rados Block Device mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/rbd/README.md","$ref":"#/components/schemas/v1.RBDVolumeSource"},"scaleIO":{"description":"scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.ScaleIOVolumeSource"},"secret":{"description":"secret represents a secret that should populate this volume. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","$ref":"#/components/schemas/v1.SecretVolumeSource"},"storageos":{"description":"storageOS represents a StorageOS volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.StorageOSVolumeSource"},"vsphereVolume":{"description":"vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.VsphereVirtualDiskVolumeSource"}}},"v1.AWSElasticBlockStoreVolumeSource":{"description":"Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).","type":"integer","format":"int32"},"readOnly":{"description":"readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"boolean"},"volumeID":{"description":"volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"}}},"v1.AzureDiskVolumeSource":{"description":"AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","required":["diskName","diskURI"],"properties":{"cachingMode":{"description":"cachingMode is the Host Caching mode: None, Read Only, Read Write.","type":"string"},"diskName":{"description":"diskName is the Name of the data disk in the blob storage","type":"string"},"diskURI":{"description":"diskURI is the URI of data disk in the blob storage","type":"string"},"fsType":{"description":"fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"kind":{"description":"kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"}}},"v1.AzureFileVolumeSource":{"description":"AzureFile represents an Azure File Service mount on the host and bind mount to the pod.","required":["secretName","shareName"],"properties":{"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretName":{"description":"secretName is the name of secret that contains Azure Storage Account Name and Key","type":"string"},"shareName":{"description":"shareName is the azure share Name","type":"string"}}},"v1.CephFSVolumeSource":{"description":"Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.","required":["monitors"],"properties":{"monitors":{"description":"monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"path":{"description":"path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /","type":"string"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"boolean"},"secretFile":{"description":"secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"},"secretRef":{"description":"secretRef is Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"}}},"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}},"v1.CinderVolumeSource":{"description":"Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"boolean"},"secretRef":{"description":"secretRef is optional: points to a secret object containing parameters used to connect to OpenStack.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeID":{"description":"volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"}}},"v1.ConfigMapVolumeSource":{"description":"Adapts a ConfigMap into a volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.KeyToPath":{"description":"Maps a string key to a path within a volume.","required":["key","path"],"properties":{"key":{"description":"key is the key to project.","type":"string"},"mode":{"description":"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.","type":"string"}}},"v1.CSIVolumeSource":{"description":"Represents a source location of a volume to mount, managed by an external CSI driver","required":["driver"],"properties":{"driver":{"description":"driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.","type":"string"},"fsType":{"description":"fsType to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.","type":"string"},"nodePublishSecretRef":{"description":"nodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secret references are passed.","$ref":"#/components/schemas/v1.LocalObjectReference"},"readOnly":{"description":"readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).","type":"boolean"},"volumeAttributes":{"description":"volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.","type":"object","additionalProperties":{"type":"string"}}}},"v1.DownwardAPIVolumeSource":{"description":"DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"Items is a list of downward API volume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.DownwardAPIVolumeFile":{"description":"DownwardAPIVolumeFile represents information to create the file containing the pod field","required":["path"],"properties":{"fieldRef":{"description":"Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"mode":{"description":"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'","type":"string"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"}}},"v1.EmptyDirVolumeSource":{"description":"Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.","properties":{"medium":{"description":"medium represents what type of storage medium should back this directory. The default is \"\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","type":"string"},"sizeLimit":{"description":"sizeLimit is the total amount of local storage required for this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. The default is nil which means that the limit is undefined. More info: http://kubernetes.io/docs/user-guide/volumes#emptydir","$ref":"#/components/schemas/resource.Quantity"}}},"v1.EphemeralVolumeSource":{"description":"Represents an ephemeral volume that is handled by a normal storage driver.","properties":{"volumeClaimTemplate":{"description":"Will be used to create a stand-alone PVC to provision the volume. The pod in which this EphemeralVolumeSource is embedded will be the owner of the PVC, i.e. the PVC will be deleted together with the pod. The name of the PVC will be `-` where `` is the name from the `PodSpec.Volumes` array entry. Pod validation will reject the pod if the concatenated name is not valid for a PVC (for example, too long).\n\nAn existing PVC with that name that is not owned by the pod will *not* be used for the pod to avoid using an unrelated volume by mistake. Starting the pod is then blocked until the unrelated PVC is removed. If such a pre-created PVC is meant to be used by the pod, the PVC has to updated with an owner reference to the pod once the pod exists. Normally this should not be necessary, but it may be useful when manually reconstructing a broken cluster.\n\nThis field is read-only and no changes will be made by Kubernetes to the PVC after it has been created.\n\nRequired, must not be nil.","$ref":"#/components/schemas/v1.PersistentVolumeClaimTemplate"}}},"v1.PersistentVolumeClaimTemplate":{"description":"PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.","required":["spec"],"properties":{"metadata":{"description":"May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"The specification for the PersistentVolumeClaim. The entire content is copied unchanged into the PVC that gets created from this template. The same fields as in a PersistentVolumeClaim are also valid here.","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"}}},"v1.ObjectMeta":{"description":"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.","properties":{"annotations":{"description":"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations","type":"object","additionalProperties":{"type":"string"}},"clusterName":{"description":"Deprecated: ClusterName is a legacy field that was always cleared by the system and never used; it will be removed completely in 1.25.\n\nThe name in the go struct is changed to help clients detect accidental use.","type":"string"},"creationTimestamp":{"description":"CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"deletionGracePeriodSeconds":{"description":"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.","type":"integer","format":"int64"},"deletionTimestamp":{"description":"DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"finalizers":{"description":"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.","type":"array","items":{"type":"string"}},"generateName":{"description":"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency","type":"string"},"generation":{"description":"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.","type":"integer","format":"int64"},"labels":{"description":"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels","type":"object","additionalProperties":{"type":"string"}},"managedFields":{"description":"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.","type":"array","items":{"$ref":"#/components/schemas/v1.ManagedFieldsEntry"}},"name":{"description":"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"namespace":{"description":"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces","type":"string"},"ownerReferences":{"description":"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.","type":"array","items":{"$ref":"#/components/schemas/v1.OwnerReference"}},"resourceVersion":{"description":"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency","type":"string"},"selfLink":{"description":"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.","type":"string"},"uid":{"description":"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}},"v1.ManagedFieldsEntry":{"description":"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.","properties":{"apiVersion":{"description":"APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.","type":"string"},"fieldsType":{"description":"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"","type":"string"},"fieldsV1":{"description":"FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type.","$ref":"#/components/schemas/v1.FieldsV1"},"manager":{"description":"Manager is an identifier of the workflow managing these fields.","type":"string"},"operation":{"description":"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.","type":"string"},"subresource":{"description":"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.","type":"string"},"time":{"description":"Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over.","$ref":"#/components/schemas/v1.Time"}}},"v1.FieldsV1":{"description":"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff"},"v1.OwnerReference":{"description":"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.","required":["apiVersion","kind","name","uid"],"properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"blockOwnerDeletion":{"description":"If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.","type":"boolean"},"controller":{"description":"If true, this reference points to the managing controller.","type":"boolean"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"uid":{"description":"UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.PersistentVolumeClaimSpec":{"description":"PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes","properties":{"accessModes":{"description":"accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"dataSource":{"description":"dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"dataSourceRef":{"description":"dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"resources":{"description":"resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources","$ref":"#/components/schemas/v1.ResourceRequirements"},"selector":{"description":"selector is a label query over volumes to consider for binding.","$ref":"#/components/schemas/v1.LabelSelector"},"storageClassName":{"description":"storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1","type":"string"},"volumeMode":{"description":"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.","type":"string"},"volumeName":{"description":"volumeName is the binding reference to the PersistentVolume backing this claim.","type":"string"}}},"v1.TypedLocalObjectReference":{"description":"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.","required":["apiGroup","kind","name"],"properties":{"apiGroup":{"description":"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.","type":"string"},"kind":{"description":"Kind is the type of resource being referenced","type":"string"},"name":{"description":"Name is the name of resource being referenced","type":"string"}}},"v1.FCVolumeSource":{"description":"Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"lun":{"description":"lun is Optional: FC target lun number","type":"integer","format":"int32"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"targetWWNs":{"description":"targetWWNs is Optional: FC target worldwide names (WWNs)","type":"array","items":{"type":"string"}},"wwids":{"description":"wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.","type":"array","items":{"type":"string"}}}},"v1.FlexVolumeSource":{"description":"FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","required":["driver"],"properties":{"driver":{"description":"driver is the name of the driver to use for this volume.","type":"string"},"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.","type":"string"},"options":{"description":"options is Optional: this field holds extra command options if any.","type":"object","additionalProperties":{"type":"string"}},"readOnly":{"description":"readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef is Optional: secretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts.","$ref":"#/components/schemas/v1.LocalObjectReference"}}},"v1.FlockerVolumeSource":{"description":"Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.","properties":{"datasetName":{"description":"datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated","type":"string"},"datasetUUID":{"description":"datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset","type":"string"}}},"v1.GCEPersistentDiskVolumeSource":{"description":"Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.","required":["pdName"],"properties":{"fsType":{"description":"fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"integer","format":"int32"},"pdName":{"description":"pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"boolean"}}},"v1.GitRepoVolumeSource":{"description":"Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","required":["repository"],"properties":{"directory":{"description":"directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.","type":"string"},"repository":{"description":"repository is the URL","type":"string"},"revision":{"description":"revision is the commit hash for the specified revision.","type":"string"}}},"v1.GlusterfsVolumeSource":{"description":"Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.","required":["endpoints","path"],"properties":{"endpoints":{"description":"endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"path":{"description":"path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"readOnly":{"description":"readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"boolean"}}},"v1.HostPathVolumeSource":{"description":"Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.","required":["path"],"properties":{"path":{"description":"path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"},"type":{"description":"type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"}}},"v1.ISCSIVolumeSource":{"description":"Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.","required":["targetPortal","iqn","lun"],"properties":{"chapAuthDiscovery":{"description":"chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication","type":"boolean"},"chapAuthSession":{"description":"chapAuthSession defines whether support iSCSI Session CHAP authentication","type":"boolean"},"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi","type":"string"},"initiatorName":{"description":"initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.","type":"string"},"iqn":{"description":"iqn is the target iSCSI Qualified Name.","type":"string"},"iscsiInterface":{"description":"iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).","type":"string"},"lun":{"description":"lun represents iSCSI Target Lun number.","type":"integer","format":"int32"},"portals":{"description":"portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"array","items":{"type":"string"}},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.","type":"boolean"},"secretRef":{"description":"secretRef is the CHAP Secret for iSCSI target and initiator authentication","$ref":"#/components/schemas/v1.LocalObjectReference"},"targetPortal":{"description":"targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"string"}}},"v1.NFSVolumeSource":{"description":"Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.","required":["server","path"],"properties":{"path":{"description":"path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"},"readOnly":{"description":"readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"boolean"},"server":{"description":"server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"}}},"v1.PersistentVolumeClaimVolumeSource":{"description":"PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).","required":["claimName"],"properties":{"claimName":{"description":"claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","type":"string"},"readOnly":{"description":"readOnly Will force the ReadOnly setting in VolumeMounts. Default false.","type":"boolean"}}},"v1.PhotonPersistentDiskVolumeSource":{"description":"Represents a Photon Controller persistent disk resource.","required":["pdID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"pdID":{"description":"pdID is the ID that identifies Photon Controller persistent disk","type":"string"}}},"v1.PortworxVolumeSource":{"description":"PortworxVolumeSource represents a Portworx volume resource.","required":["volumeID"],"properties":{"fsType":{"description":"fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"volumeID":{"description":"volumeID uniquely identifies a Portworx volume","type":"string"}}},"v1.ProjectedVolumeSource":{"description":"Represents a projected volume source","required":["sources"],"properties":{"defaultMode":{"description":"defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"sources":{"description":"sources is the list of volume projections","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeProjection"}}}},"v1.VolumeProjection":{"description":"Projection that may be projected along with other supported volume types","properties":{"configMap":{"description":"configMap information about the configMap data to project","$ref":"#/components/schemas/v1.ConfigMapProjection"},"downwardAPI":{"description":"downwardAPI information about the downwardAPI data to project","$ref":"#/components/schemas/v1.DownwardAPIProjection"},"secret":{"description":"secret information about the secret data to project","$ref":"#/components/schemas/v1.SecretProjection"},"serviceAccountToken":{"description":"serviceAccountToken is information about the serviceAccountToken data to project","$ref":"#/components/schemas/v1.ServiceAccountTokenProjection"}}},"v1.ConfigMapProjection":{"description":"Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.DownwardAPIProjection":{"description":"Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.","properties":{"items":{"description":"Items is a list of DownwardAPIVolume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.SecretProjection":{"description":"Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional field specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.ServiceAccountTokenProjection":{"description":"ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).","required":["path"],"properties":{"audience":{"description":"audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.","type":"string"},"expirationSeconds":{"description":"expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.","type":"integer","format":"int64"},"path":{"description":"path is the path relative to the mount point of the file to project the token into.","type":"string"}}},"v1.QuobyteVolumeSource":{"description":"Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.","required":["registry","volume"],"properties":{"group":{"description":"group to map volume access to Default is no group","type":"string"},"readOnly":{"description":"readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.","type":"boolean"},"registry":{"description":"registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes","type":"string"},"tenant":{"description":"tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin","type":"string"},"user":{"description":"user to map volume access to Defaults to serivceaccount user","type":"string"},"volume":{"description":"volume is a string that references an already created Quobyte volume by name.","type":"string"}}},"v1.RBDVolumeSource":{"description":"Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.","required":["monitors","image"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd","type":"string"},"image":{"description":"image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"keyring":{"description":"keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"monitors":{"description":"monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"pool":{"description":"pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"boolean"},"secretRef":{"description":"secretRef is name of the authentication secret for RBDUser. If provided overrides keyring. Default is nil. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"}}},"v1.ScaleIOVolumeSource":{"description":"ScaleIOVolumeSource represents a persistent ScaleIO volume","required":["gateway","system","secretRef"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\".","type":"string"},"gateway":{"description":"gateway is the host address of the ScaleIO API Gateway.","type":"string"},"protectionDomain":{"description":"protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef references to the secret for ScaleIO user and other sensitive information. If this is not provided, Login operation will fail.","$ref":"#/components/schemas/v1.LocalObjectReference"},"sslEnabled":{"description":"sslEnabled Flag enable/disable SSL communication with Gateway, default false","type":"boolean"},"storageMode":{"description":"storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.","type":"string"},"storagePool":{"description":"storagePool is the ScaleIO Storage Pool associated with the protection domain.","type":"string"},"system":{"description":"system is the name of the storage system as configured in ScaleIO.","type":"string"},"volumeName":{"description":"volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.","type":"string"}}},"v1.SecretVolumeSource":{"description":"Adapts a Secret into a volume.\n\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"optional":{"description":"optional field specify whether the Secret or its keys must be defined","type":"boolean"},"secretName":{"description":"secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","type":"string"}}},"v1.StorageOSVolumeSource":{"description":"Represents a StorageOS persistent volume resource.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeName":{"description":"volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.","type":"string"},"volumeNamespace":{"description":"volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.","type":"string"}}},"v1.VsphereVirtualDiskVolumeSource":{"description":"Represents a vSphere volume resource.","required":["volumePath"],"properties":{"fsType":{"description":"fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"storagePolicyID":{"description":"storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.","type":"string"},"storagePolicyName":{"description":"storagePolicyName is the storage Policy Based Management (SPBM) profile name.","type":"string"},"volumePath":{"description":"volumePath is the path that identifies vSphere volume vmdk","type":"string"}}},"v1alpha1.Item":{},"v1alpha1.Sequence":{"properties":{"count":{"$ref":"#/components/schemas/intstr.IntOrString"},"end":{"$ref":"#/components/schemas/intstr.IntOrString"},"format":{"type":"string"},"start":{"$ref":"#/components/schemas/intstr.IntOrString"}}}}}} ``` ## The v1alpha1.Data object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Data":{"required":["source","transformation"],"properties":{"source":{"$ref":"#/components/schemas/v1alpha1.DataSource"},"transformation":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.TransformationStep"}}}},"v1alpha1.DataSource":{"properties":{"artifactPaths":{"$ref":"#/components/schemas/v1alpha1.ArtifactPaths"}}},"v1alpha1.ArtifactPaths":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.TransformationStep":{"required":["expression"],"properties":{"expression":{"type":"string"}}}}}} ``` ## The v1alpha1.DataSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.DataSource":{"properties":{"artifactPaths":{"$ref":"#/components/schemas/v1alpha1.ArtifactPaths"}}},"v1alpha1.ArtifactPaths":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}}}}} ``` ## The v1alpha1.ExecutorConfig object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ExecutorConfig":{"properties":{"serviceAccountName":{"type":"string"}}}}}} ``` ## The v1alpha1.GCSArtifact object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}}}}} ``` ## The v1alpha1.GCSArtifactRepository object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.GCSArtifactRepository":{"properties":{"bucket":{"type":"string"},"keyFormat":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}}}}} ``` ## The v1alpha1.Gauge object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Gauge":{"required":["value","realtime"],"properties":{"operation":{"type":"string"},"realtime":{"type":"boolean"},"value":{"type":"string"}}}}}} ``` ## The v1alpha1.GitArtifact object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}}}}} ``` ## The v1alpha1.HDFSArtifact object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}}}}} ``` ## The v1alpha1.HDFSArtifactRepository object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.HDFSArtifactRepository":{"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"pathFormat":{"type":"string"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}}}}} ``` ## The v1alpha1.HTTP object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.HTTP":{"required":["url"],"properties":{"body":{"type":"string"},"bodyFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPBodySource"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.HTTPHeader"}},"insecureSkipVerify":{"type":"boolean"},"method":{"type":"string"},"successCondition":{"type":"string"},"timeoutSeconds":{"type":"integer","format":"int64"},"url":{"type":"string"}}},"v1alpha1.HTTPBodySource":{"properties":{"bytes":{"type":"string"}}},"v1alpha1.HTTPHeader":{"required":["name"],"properties":{"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPHeaderSource"}}},"v1alpha1.HTTPHeaderSource":{"properties":{"secretKeyRef":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}}}}} ``` ## The v1alpha1.HTTPArtifact object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}}}}} ``` ## The v1alpha1.HTTPAuth object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}}}}} ``` ## The v1alpha1.HTTPBodySource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.HTTPBodySource":{"properties":{"bytes":{"type":"string"}}}}}} ``` ## The v1alpha1.HTTPHeader object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.HTTPHeader":{"required":["name"],"properties":{"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPHeaderSource"}}},"v1alpha1.HTTPHeaderSource":{"properties":{"secretKeyRef":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}}}}} ``` ## The v1alpha1.HTTPHeaderSource object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.HTTPHeaderSource":{"properties":{"secretKeyRef":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}}}}} ``` ## The v1alpha1.Header object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}}}}} ``` ## The v1alpha1.Histogram object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Histogram":{"required":["value","buckets"],"properties":{"buckets":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Amount"}},"value":{"type":"string"}}},"v1alpha1.Amount":{}}}} ``` ## The v1alpha1.Inputs object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Inputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Artifact":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.Parameter":{"required":["name"],"properties":{"default":{"type":"string"},"description":{"type":"string"},"enum":{"type":"array","items":{"type":"string"}},"globalName":{"type":"string"},"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.ValueFrom"}}},"v1alpha1.ValueFrom":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"default":{"type":"string"},"event":{"type":"string"},"expression":{"type":"string"},"jqFilter":{"type":"string"},"jsonPath":{"type":"string"},"parameter":{"type":"string"},"path":{"type":"string"},"supplied":{"$ref":"#/components/schemas/v1alpha1.SuppliedValueFrom"}}},"v1alpha1.SuppliedValueFrom":{}}}} ``` ## The v1alpha1.Item object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Item":{}}}} ``` ## The v1alpha1.LabelValueFrom object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.LabelValueFrom":{"required":["expression"],"properties":{"expression":{"type":"string"}}}}}} ``` ## The v1alpha1.LifecycleHook object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.LifecycleHook":{"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"expression":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"}}},"v1alpha1.Arguments":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Artifact":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.Parameter":{"required":["name"],"properties":{"default":{"type":"string"},"description":{"type":"string"},"enum":{"type":"array","items":{"type":"string"}},"globalName":{"type":"string"},"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.ValueFrom"}}},"v1alpha1.ValueFrom":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"default":{"type":"string"},"event":{"type":"string"},"expression":{"type":"string"},"jqFilter":{"type":"string"},"jsonPath":{"type":"string"},"parameter":{"type":"string"},"path":{"type":"string"},"supplied":{"$ref":"#/components/schemas/v1alpha1.SuppliedValueFrom"}}},"v1alpha1.SuppliedValueFrom":{},"v1alpha1.TemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"},"template":{"type":"string"}}}}}} ``` ## The v1alpha1.ManifestFrom object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ManifestFrom":{"required":["artifact"],"properties":{"artifact":{"$ref":"#/components/schemas/v1alpha1.Artifact"}}},"v1alpha1.Artifact":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}}}}} ``` ## The v1alpha1.MemoizationStatus object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.MemoizationStatus":{"required":["hit","key","cacheName"],"properties":{"cacheName":{"type":"string"},"hit":{"type":"boolean"},"key":{"type":"string"}}}}}} ``` ## The v1alpha1.Memoize object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Memoize":{"required":["key","cache","maxAge"],"properties":{"cache":{"$ref":"#/components/schemas/v1alpha1.Cache"},"key":{"type":"string"},"maxAge":{"type":"string"}}},"v1alpha1.Cache":{"required":["configMap"],"properties":{"configMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}}}}} ``` ## The v1alpha1.Metadata object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}}}}} ``` ## The v1alpha1.MetricLabel object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.MetricLabel":{"required":["key","value"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}}}}} ``` ## The v1alpha1.Metrics object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Metrics":{"required":["prometheus"],"properties":{"prometheus":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Prometheus"}}}},"v1alpha1.Prometheus":{"required":["name","help"],"properties":{"counter":{"$ref":"#/components/schemas/v1alpha1.Counter"},"gauge":{"$ref":"#/components/schemas/v1alpha1.Gauge"},"help":{"type":"string"},"histogram":{"$ref":"#/components/schemas/v1alpha1.Histogram"},"labels":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MetricLabel"}},"name":{"type":"string"},"when":{"type":"string"}}},"v1alpha1.Counter":{"required":["value"],"properties":{"value":{"type":"string"}}},"v1alpha1.Gauge":{"required":["value","realtime"],"properties":{"operation":{"type":"string"},"realtime":{"type":"boolean"},"value":{"type":"string"}}},"v1alpha1.Histogram":{"required":["value","buckets"],"properties":{"buckets":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Amount"}},"value":{"type":"string"}}},"v1alpha1.Amount":{},"v1alpha1.MetricLabel":{"required":["key","value"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}}}}} ``` ## The v1alpha1.Mutex object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Mutex":{"properties":{"name":{"type":"string"},"namespace":{"type":"string"}}}}}} ``` ## The v1alpha1.MutexHolding object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.MutexHolding":{"properties":{"holder":{"type":"string"},"mutex":{"type":"string"}}}}}} ``` ## The v1alpha1.MutexStatus object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.MutexStatus":{"properties":{"holding":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MutexHolding"}},"waiting":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MutexHolding"}}}},"v1alpha1.MutexHolding":{"properties":{"holder":{"type":"string"},"mutex":{"type":"string"}}}}}} ``` ## The v1alpha1.NodeFlag object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.NodeFlag":{"properties":{"hooked":{"type":"boolean"},"retried":{"type":"boolean"}}}}}} ``` ## The v1alpha1.NodeStatus object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.NodeStatus":{"required":["id","name","type"],"properties":{"boundaryID":{"type":"string"},"children":{"type":"array","items":{"type":"string"}},"daemoned":{"type":"boolean"},"displayName":{"type":"string"},"estimatedDuration":{"type":"integer","format":"int32"},"finishedAt":{"$ref":"#/components/schemas/v1.Time"},"hostNodeName":{"type":"string"},"id":{"type":"string"},"inputs":{"$ref":"#/components/schemas/v1alpha1.Inputs"},"memoizationStatus":{"$ref":"#/components/schemas/v1alpha1.MemoizationStatus"},"message":{"type":"string"},"name":{"type":"string"},"nodeFlag":{"$ref":"#/components/schemas/v1alpha1.NodeFlag"},"outboundNodes":{"type":"array","items":{"type":"string"}},"outputs":{"$ref":"#/components/schemas/v1alpha1.Outputs"},"phase":{"type":"string"},"podIP":{"type":"string"},"progress":{"type":"string"},"resourcesDuration":{"type":"object","additionalProperties":{"type":"integer"}},"startedAt":{"$ref":"#/components/schemas/v1.Time"},"synchronizationStatus":{"$ref":"#/components/schemas/v1alpha1.NodeSynchronizationStatus"},"templateName":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"},"templateScope":{"type":"string"},"type":{"type":"string"}}},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}},"v1alpha1.Inputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Artifact":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.Parameter":{"required":["name"],"properties":{"default":{"type":"string"},"description":{"type":"string"},"enum":{"type":"array","items":{"type":"string"}},"globalName":{"type":"string"},"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.ValueFrom"}}},"v1alpha1.ValueFrom":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"default":{"type":"string"},"event":{"type":"string"},"expression":{"type":"string"},"jqFilter":{"type":"string"},"jsonPath":{"type":"string"},"parameter":{"type":"string"},"path":{"type":"string"},"supplied":{"$ref":"#/components/schemas/v1alpha1.SuppliedValueFrom"}}},"v1alpha1.SuppliedValueFrom":{},"v1alpha1.MemoizationStatus":{"required":["hit","key","cacheName"],"properties":{"cacheName":{"type":"string"},"hit":{"type":"boolean"},"key":{"type":"string"}}},"v1alpha1.NodeFlag":{"properties":{"hooked":{"type":"boolean"},"retried":{"type":"boolean"}}},"v1alpha1.Outputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"exitCode":{"type":"string"},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}},"result":{"type":"string"}}},"v1alpha1.NodeSynchronizationStatus":{"properties":{"waiting":{"type":"string"}}},"v1alpha1.TemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"},"template":{"type":"string"}}}}}} ``` ## The v1alpha1.NodeSynchronizationStatus object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.NodeSynchronizationStatus":{"properties":{"waiting":{"type":"string"}}}}}} ``` ## The v1alpha1.NoneStrategy object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.NoneStrategy":{}}}} ``` ## The v1alpha1.OAuth2Auth object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}}}}} ``` ## The v1alpha1.OAuth2EndpointParam object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}}}}} ``` ## The v1alpha1.OSSArtifact object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}}}}} ``` ## The v1alpha1.OSSArtifactRepository object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.OSSArtifactRepository":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"keyFormat":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}}}}} ``` ## The v1alpha1.OSSLifecycleRule object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}}}}} ``` ## The v1alpha1.Outputs object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Outputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"exitCode":{"type":"string"},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}},"result":{"type":"string"}}},"v1alpha1.Artifact":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.Parameter":{"required":["name"],"properties":{"default":{"type":"string"},"description":{"type":"string"},"enum":{"type":"array","items":{"type":"string"}},"globalName":{"type":"string"},"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.ValueFrom"}}},"v1alpha1.ValueFrom":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"default":{"type":"string"},"event":{"type":"string"},"expression":{"type":"string"},"jqFilter":{"type":"string"},"jsonPath":{"type":"string"},"parameter":{"type":"string"},"path":{"type":"string"},"supplied":{"$ref":"#/components/schemas/v1alpha1.SuppliedValueFrom"}}},"v1alpha1.SuppliedValueFrom":{}}}} ``` ## The v1alpha1.ParallelSteps object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ParallelSteps":{}}}} ``` ## The v1alpha1.Parameter object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Parameter":{"required":["name"],"properties":{"default":{"type":"string"},"description":{"type":"string"},"enum":{"type":"array","items":{"type":"string"}},"globalName":{"type":"string"},"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.ValueFrom"}}},"v1alpha1.ValueFrom":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"default":{"type":"string"},"event":{"type":"string"},"expression":{"type":"string"},"jqFilter":{"type":"string"},"jsonPath":{"type":"string"},"parameter":{"type":"string"},"path":{"type":"string"},"supplied":{"$ref":"#/components/schemas/v1alpha1.SuppliedValueFrom"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.SuppliedValueFrom":{}}}} ``` ## The v1alpha1.Plugin object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Plugin":{}}}} ``` ## The v1alpha1.PodGC object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.PodGC":{"properties":{"deleteDelayDuration":{"type":"string"},"labelSelector":{"$ref":"#/components/schemas/v1.LabelSelector"},"strategy":{"type":"string"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}}}}} ``` ## The v1alpha1.Prometheus object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Prometheus":{"required":["name","help"],"properties":{"counter":{"$ref":"#/components/schemas/v1alpha1.Counter"},"gauge":{"$ref":"#/components/schemas/v1alpha1.Gauge"},"help":{"type":"string"},"histogram":{"$ref":"#/components/schemas/v1alpha1.Histogram"},"labels":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MetricLabel"}},"name":{"type":"string"},"when":{"type":"string"}}},"v1alpha1.Counter":{"required":["value"],"properties":{"value":{"type":"string"}}},"v1alpha1.Gauge":{"required":["value","realtime"],"properties":{"operation":{"type":"string"},"realtime":{"type":"boolean"},"value":{"type":"string"}}},"v1alpha1.Histogram":{"required":["value","buckets"],"properties":{"buckets":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Amount"}},"value":{"type":"string"}}},"v1alpha1.Amount":{},"v1alpha1.MetricLabel":{"required":["key","value"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}}}}} ``` ## The v1alpha1.RawArtifact object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}}}}} ``` ## The v1alpha1.ResourceTemplate object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ResourceTemplate":{"required":["action"],"properties":{"action":{"type":"string"},"failureCondition":{"type":"string"},"flags":{"type":"array","items":{"type":"string"}},"manifest":{"type":"string"},"manifestFrom":{"$ref":"#/components/schemas/v1alpha1.ManifestFrom"},"mergeStrategy":{"type":"string"},"setOwnerReference":{"type":"boolean"},"successCondition":{"type":"string"}}},"v1alpha1.ManifestFrom":{"required":["artifact"],"properties":{"artifact":{"$ref":"#/components/schemas/v1alpha1.Artifact"}}},"v1alpha1.Artifact":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}}}}} ``` ## The v1alpha1.RetryAffinity object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.RetryAffinity":{"properties":{"nodeAntiAffinity":{"$ref":"#/components/schemas/v1alpha1.RetryNodeAntiAffinity"}}},"v1alpha1.RetryNodeAntiAffinity":{}}}} ``` ## The v1alpha1.RetryNodeAntiAffinity object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.RetryNodeAntiAffinity":{}}}} ``` ## The v1alpha1.RetryStrategy object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.RetryStrategy":{"properties":{"affinity":{"$ref":"#/components/schemas/v1alpha1.RetryAffinity"},"backoff":{"$ref":"#/components/schemas/v1alpha1.Backoff"},"expression":{"type":"string"},"limit":{"$ref":"#/components/schemas/intstr.IntOrString"},"retryPolicy":{"type":"string"}}},"v1alpha1.RetryAffinity":{"properties":{"nodeAntiAffinity":{"$ref":"#/components/schemas/v1alpha1.RetryNodeAntiAffinity"}}},"v1alpha1.RetryNodeAntiAffinity":{},"v1alpha1.Backoff":{"properties":{"duration":{"type":"string"},"factor":{"$ref":"#/components/schemas/intstr.IntOrString"},"maxDuration":{"type":"string"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}}}}} ``` ## The v1alpha1.S3Artifact object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}}}}} ``` ## The v1alpha1.S3ArtifactRepository object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.S3ArtifactRepository":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"keyFormat":{"type":"string"},"keyPrefix":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}}}}} ``` ## The v1alpha1.S3EncryptionOptions object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}}}}} ``` ## The v1alpha1.ScriptTemplate object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ScriptTemplate":{"description":"A single application container that you want to run within a pod.","required":["name","source"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"source":{"type":"string"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1.EnvVar":{"description":"EnvVar represents an environment variable present in a Container.","required":["name"],"properties":{"name":{"description":"Name of the environment variable. Must be a C_IDENTIFIER.","type":"string"},"value":{"description":"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".","type":"string"},"valueFrom":{"description":"Source for the environment variable's value. Cannot be used if value is not empty.","$ref":"#/components/schemas/v1.EnvVarSource"}}},"v1.EnvVarSource":{"description":"EnvVarSource represents a source for the value of an EnvVar.","properties":{"configMapKeyRef":{"description":"Selects a key of a ConfigMap.","$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"fieldRef":{"description":"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"},"secretKeyRef":{"description":"Selects a key of a secret in the pod's namespace","$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.EnvFromSource":{"description":"EnvFromSource represents the source of a set of ConfigMaps","properties":{"configMapRef":{"description":"The ConfigMap to select from","$ref":"#/components/schemas/v1.ConfigMapEnvSource"},"prefix":{"description":"An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.","type":"string"},"secretRef":{"description":"The Secret to select from","$ref":"#/components/schemas/v1.SecretEnvSource"}}},"v1.ConfigMapEnvSource":{"description":"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap must be defined","type":"boolean"}}},"v1.SecretEnvSource":{"description":"SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret must be defined","type":"boolean"}}},"v1.Lifecycle":{"description":"Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.","properties":{"postStart":{"description":"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"},"preStop":{"description":"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"}}},"v1.LifecycleHandler":{"description":"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"tcpSocket":{"description":"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.","$ref":"#/components/schemas/v1.TCPSocketAction"}}},"v1.ExecAction":{"description":"ExecAction describes a \"run in container\" action.","properties":{"command":{"description":"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.","type":"array","items":{"type":"string"}}}},"v1.HTTPGetAction":{"description":"HTTPGetAction describes an action based on HTTP Get requests.","required":["port"],"properties":{"host":{"description":"Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.","type":"string"},"httpHeaders":{"description":"Custom headers to set in the request. HTTP allows repeated headers.","type":"array","items":{"$ref":"#/components/schemas/v1.HTTPHeader"}},"path":{"description":"Path to access on the HTTP server.","type":"string"},"port":{"description":"Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"},"scheme":{"description":"Scheme to use for connecting to the host. Defaults to HTTP.","type":"string"}}},"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}},"v1.TCPSocketAction":{"description":"TCPSocketAction describes an action based on opening a socket","required":["port"],"properties":{"host":{"description":"Optional: Host name to connect to, defaults to the pod IP.","type":"string"},"port":{"description":"Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"}}},"v1.Probe":{"description":"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"failureThreshold":{"description":"Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.","type":"integer","format":"int32"},"grpc":{"description":"GRPC specifies an action involving a GRPC port. This is a beta field and requires enabling GRPCContainerProbe feature gate.","$ref":"#/components/schemas/v1.GRPCAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"initialDelaySeconds":{"description":"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"},"periodSeconds":{"description":"How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.","type":"integer","format":"int32"},"successThreshold":{"description":"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.","type":"integer","format":"int32"},"tcpSocket":{"description":"TCPSocket specifies an action involving a TCP port.","$ref":"#/components/schemas/v1.TCPSocketAction"},"terminationGracePeriodSeconds":{"description":"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.","type":"integer","format":"int64"},"timeoutSeconds":{"description":"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"}}},"v1.GRPCAction":{"required":["port","service"],"properties":{"port":{"description":"Port number of the gRPC service. Number must be in the range 1 to 65535.","type":"integer","format":"int32"},"service":{"description":"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.","type":"string"}}},"v1.ContainerPort":{"description":"ContainerPort represents a network port in a single container.","required":["containerPort"],"properties":{"containerPort":{"description":"Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.","type":"integer","format":"int32"},"hostIP":{"description":"What host IP to bind the external port to.","type":"string"},"hostPort":{"description":"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.","type":"integer","format":"int32"},"name":{"description":"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.","type":"string"},"protocol":{"description":"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"v1.SecurityContext":{"description":"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.","properties":{"allowPrivilegeEscalation":{"description":"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"capabilities":{"description":"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.Capabilities"},"privileged":{"description":"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"procMount":{"description":"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"readOnlyRootFilesystem":{"description":"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Capabilities":{"description":"Adds and removes POSIX capabilities from running containers.","properties":{"add":{"description":"Added capabilities","type":"array","items":{"type":"string"}},"drop":{"description":"Removed capabilities","type":"array","items":{"type":"string"}}}},"v1.SELinuxOptions":{"description":"SELinuxOptions are the labels to be applied to the container","properties":{"level":{"description":"Level is SELinux level label that applies to the container.","type":"string"},"role":{"description":"Role is a SELinux role label that applies to the container.","type":"string"},"type":{"description":"Type is a SELinux type label that applies to the container.","type":"string"},"user":{"description":"User is a SELinux user label that applies to the container.","type":"string"}}},"v1.SeccompProfile":{"description":"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.","required":["type"],"properties":{"localhostProfile":{"description":"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is \"Localhost\".","type":"string"},"type":{"description":"type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.","type":"string"}}},"v1.WindowsSecurityContextOptions":{"description":"WindowsSecurityContextOptions contain Windows-specific options and credentials.","properties":{"gmsaCredentialSpec":{"description":"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.","type":"string"},"gmsaCredentialSpecName":{"description":"GMSACredentialSpecName is the name of the GMSA credential spec to use.","type":"string"},"hostProcess":{"description":"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.","type":"boolean"},"runAsUserName":{"description":"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"string"}}},"v1.VolumeDevice":{"description":"volumeDevice describes a mapping of a raw block device within a container.","required":["name","devicePath"],"properties":{"devicePath":{"description":"devicePath is the path inside of the container that the device will be mapped to.","type":"string"},"name":{"description":"name must match the name of a persistentVolumeClaim in the pod","type":"string"}}},"v1.VolumeMount":{"description":"VolumeMount describes a mounting of a Volume within a container.","required":["name","mountPath"],"properties":{"mountPath":{"description":"Path within the container at which the volume should be mounted. Must not contain ':'.","type":"string"},"mountPropagation":{"description":"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10.","type":"string"},"name":{"description":"This must match the Name of a Volume.","type":"string"},"readOnly":{"description":"Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.","type":"boolean"},"subPath":{"description":"Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).","type":"string"},"subPathExpr":{"description":"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.","type":"string"}}}}}} ``` ## The v1alpha1.SemaphoreHolding object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.SemaphoreHolding":{"properties":{"holders":{"type":"array","items":{"type":"string"}},"semaphore":{"type":"string"}}}}}} ``` ## The v1alpha1.SemaphoreRef object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.SemaphoreRef":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"namespace":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}}}}} ``` ## The v1alpha1.SemaphoreStatus object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.SemaphoreStatus":{"properties":{"holding":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.SemaphoreHolding"}},"waiting":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.SemaphoreHolding"}}}},"v1alpha1.SemaphoreHolding":{"properties":{"holders":{"type":"array","items":{"type":"string"}},"semaphore":{"type":"string"}}}}}} ``` ## The v1alpha1.Sequence object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Sequence":{"properties":{"count":{"$ref":"#/components/schemas/intstr.IntOrString"},"end":{"$ref":"#/components/schemas/intstr.IntOrString"},"format":{"type":"string"},"start":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}}}}} ``` ## The v1alpha1.SuppliedValueFrom object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.SuppliedValueFrom":{}}}} ``` ## The v1alpha1.SuspendTemplate object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.SuspendTemplate":{"properties":{"duration":{"type":"string"}}}}}} ``` ## The v1alpha1.Synchronization object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Synchronization":{"properties":{"mutex":{"$ref":"#/components/schemas/v1alpha1.Mutex"},"semaphore":{"$ref":"#/components/schemas/v1alpha1.SemaphoreRef"}}},"v1alpha1.Mutex":{"properties":{"name":{"type":"string"},"namespace":{"type":"string"}}},"v1alpha1.SemaphoreRef":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"namespace":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}}}}} ``` ## The v1alpha1.SynchronizationStatus object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.SynchronizationStatus":{"properties":{"mutex":{"$ref":"#/components/schemas/v1alpha1.MutexStatus"},"semaphore":{"$ref":"#/components/schemas/v1alpha1.SemaphoreStatus"}}},"v1alpha1.MutexStatus":{"properties":{"holding":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MutexHolding"}},"waiting":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MutexHolding"}}}},"v1alpha1.MutexHolding":{"properties":{"holder":{"type":"string"},"mutex":{"type":"string"}}},"v1alpha1.SemaphoreStatus":{"properties":{"holding":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.SemaphoreHolding"}},"waiting":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.SemaphoreHolding"}}}},"v1alpha1.SemaphoreHolding":{"properties":{"holders":{"type":"array","items":{"type":"string"}},"semaphore":{"type":"string"}}}}}} ``` ## The v1alpha1.TTLStrategy object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.TTLStrategy":{"properties":{"secondsAfterCompletion":{"type":"integer","format":"int32"},"secondsAfterFailure":{"type":"integer","format":"int32"},"secondsAfterSuccess":{"type":"integer","format":"int32"}}}}}} ``` ## The v1alpha1.TarStrategy object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}}}}} ``` ## The v1alpha1.Template object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Template":{"properties":{"activeDeadlineSeconds":{"$ref":"#/components/schemas/intstr.IntOrString"},"affinity":{"$ref":"#/components/schemas/v1.Affinity"},"archiveLocation":{"$ref":"#/components/schemas/v1alpha1.ArtifactLocation"},"automountServiceAccountToken":{"type":"boolean"},"container":{"$ref":"#/components/schemas/v1.Container"},"containerSet":{"$ref":"#/components/schemas/v1alpha1.ContainerSetTemplate"},"daemon":{"type":"boolean"},"dag":{"$ref":"#/components/schemas/v1alpha1.DAGTemplate"},"data":{"$ref":"#/components/schemas/v1alpha1.Data"},"executor":{"$ref":"#/components/schemas/v1alpha1.ExecutorConfig"},"failFast":{"type":"boolean"},"hostAliases":{"type":"array","items":{"$ref":"#/components/schemas/v1.HostAlias"}},"http":{"$ref":"#/components/schemas/v1alpha1.HTTP"},"initContainers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"inputs":{"$ref":"#/components/schemas/v1alpha1.Inputs"},"memoize":{"$ref":"#/components/schemas/v1alpha1.Memoize"},"metadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"metrics":{"$ref":"#/components/schemas/v1alpha1.Metrics"},"name":{"type":"string"},"nodeSelector":{"type":"object","additionalProperties":{"type":"string"}},"outputs":{"$ref":"#/components/schemas/v1alpha1.Outputs"},"parallelism":{"type":"integer","format":"int64"},"plugin":{"$ref":"#/components/schemas/v1alpha1.Plugin"},"podSpecPatch":{"type":"string"},"priority":{"type":"integer","format":"int32"},"priorityClassName":{"type":"string"},"resource":{"$ref":"#/components/schemas/v1alpha1.ResourceTemplate"},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.RetryStrategy"},"schedulerName":{"type":"string"},"script":{"$ref":"#/components/schemas/v1alpha1.ScriptTemplate"},"securityContext":{"$ref":"#/components/schemas/v1.PodSecurityContext"},"serviceAccountName":{"type":"string"},"sidecars":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"steps":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ParallelSteps"}},"suspend":{"$ref":"#/components/schemas/v1alpha1.SuspendTemplate"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.Synchronization"},"timeout":{"type":"string"},"tolerations":{"type":"array","items":{"$ref":"#/components/schemas/v1.Toleration"}},"volumes":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}},"v1.Affinity":{"description":"Affinity is a group of affinity scheduling rules.","properties":{"nodeAffinity":{"description":"Describes node affinity scheduling rules for the pod.","$ref":"#/components/schemas/v1.NodeAffinity"},"podAffinity":{"description":"Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAffinity"},"podAntiAffinity":{"description":"Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAntiAffinity"}}},"v1.NodeAffinity":{"description":"Node affinity is a group of node affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.PreferredSchedulingTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.","$ref":"#/components/schemas/v1.NodeSelector"}}},"v1.PreferredSchedulingTerm":{"description":"An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).","required":["weight","preference"],"properties":{"preference":{"description":"A node selector term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.NodeSelectorTerm"},"weight":{"description":"Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.NodeSelectorTerm":{"description":"A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.","properties":{"matchExpressions":{"description":"A list of node selector requirements by node's labels.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}},"matchFields":{"description":"A list of node selector requirements by node's fields.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}}}},"v1.NodeSelectorRequirement":{"description":"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"The label key that the selector applies to.","type":"string"},"operator":{"description":"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.","type":"string"},"values":{"description":"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.NodeSelector":{"description":"A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.","required":["nodeSelectorTerms"],"properties":{"nodeSelectorTerms":{"description":"Required. A list of node selector terms. The terms are ORed.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorTerm"}}}},"v1.PodAffinity":{"description":"Pod affinity is a group of inter pod affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1.WeightedPodAffinityTerm":{"description":"The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)","required":["weight","podAffinityTerm"],"properties":{"podAffinityTerm":{"description":"Required. A pod affinity term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.PodAffinityTerm"},"weight":{"description":"weight associated with matching the corresponding podAffinityTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.PodAffinityTerm":{"description":"Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running","required":["topologyKey"],"properties":{"labelSelector":{"description":"A label query over a set of resources, in this case pods.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaceSelector":{"description":"A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means \"this pod's namespace\". An empty selector ({}) matches all namespaces.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaces":{"description":"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".","type":"array","items":{"type":"string"}},"topologyKey":{"description":"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.","type":"string"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.PodAntiAffinity":{"description":"Pod anti affinity is a group of inter pod anti affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1alpha1.ArtifactLocation":{"properties":{"archiveLogs":{"type":"boolean"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.Container":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1.EnvVar":{"description":"EnvVar represents an environment variable present in a Container.","required":["name"],"properties":{"name":{"description":"Name of the environment variable. Must be a C_IDENTIFIER.","type":"string"},"value":{"description":"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".","type":"string"},"valueFrom":{"description":"Source for the environment variable's value. Cannot be used if value is not empty.","$ref":"#/components/schemas/v1.EnvVarSource"}}},"v1.EnvVarSource":{"description":"EnvVarSource represents a source for the value of an EnvVar.","properties":{"configMapKeyRef":{"description":"Selects a key of a ConfigMap.","$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"fieldRef":{"description":"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"},"secretKeyRef":{"description":"Selects a key of a secret in the pod's namespace","$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.EnvFromSource":{"description":"EnvFromSource represents the source of a set of ConfigMaps","properties":{"configMapRef":{"description":"The ConfigMap to select from","$ref":"#/components/schemas/v1.ConfigMapEnvSource"},"prefix":{"description":"An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.","type":"string"},"secretRef":{"description":"The Secret to select from","$ref":"#/components/schemas/v1.SecretEnvSource"}}},"v1.ConfigMapEnvSource":{"description":"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap must be defined","type":"boolean"}}},"v1.SecretEnvSource":{"description":"SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret must be defined","type":"boolean"}}},"v1.Lifecycle":{"description":"Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.","properties":{"postStart":{"description":"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"},"preStop":{"description":"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"}}},"v1.LifecycleHandler":{"description":"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"tcpSocket":{"description":"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.","$ref":"#/components/schemas/v1.TCPSocketAction"}}},"v1.ExecAction":{"description":"ExecAction describes a \"run in container\" action.","properties":{"command":{"description":"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.","type":"array","items":{"type":"string"}}}},"v1.HTTPGetAction":{"description":"HTTPGetAction describes an action based on HTTP Get requests.","required":["port"],"properties":{"host":{"description":"Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.","type":"string"},"httpHeaders":{"description":"Custom headers to set in the request. HTTP allows repeated headers.","type":"array","items":{"$ref":"#/components/schemas/v1.HTTPHeader"}},"path":{"description":"Path to access on the HTTP server.","type":"string"},"port":{"description":"Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"},"scheme":{"description":"Scheme to use for connecting to the host. Defaults to HTTP.","type":"string"}}},"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}},"v1.TCPSocketAction":{"description":"TCPSocketAction describes an action based on opening a socket","required":["port"],"properties":{"host":{"description":"Optional: Host name to connect to, defaults to the pod IP.","type":"string"},"port":{"description":"Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"}}},"v1.Probe":{"description":"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"failureThreshold":{"description":"Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.","type":"integer","format":"int32"},"grpc":{"description":"GRPC specifies an action involving a GRPC port. This is a beta field and requires enabling GRPCContainerProbe feature gate.","$ref":"#/components/schemas/v1.GRPCAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"initialDelaySeconds":{"description":"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"},"periodSeconds":{"description":"How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.","type":"integer","format":"int32"},"successThreshold":{"description":"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.","type":"integer","format":"int32"},"tcpSocket":{"description":"TCPSocket specifies an action involving a TCP port.","$ref":"#/components/schemas/v1.TCPSocketAction"},"terminationGracePeriodSeconds":{"description":"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.","type":"integer","format":"int64"},"timeoutSeconds":{"description":"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"}}},"v1.GRPCAction":{"required":["port","service"],"properties":{"port":{"description":"Port number of the gRPC service. Number must be in the range 1 to 65535.","type":"integer","format":"int32"},"service":{"description":"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.","type":"string"}}},"v1.ContainerPort":{"description":"ContainerPort represents a network port in a single container.","required":["containerPort"],"properties":{"containerPort":{"description":"Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.","type":"integer","format":"int32"},"hostIP":{"description":"What host IP to bind the external port to.","type":"string"},"hostPort":{"description":"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.","type":"integer","format":"int32"},"name":{"description":"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.","type":"string"},"protocol":{"description":"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"v1.SecurityContext":{"description":"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.","properties":{"allowPrivilegeEscalation":{"description":"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"capabilities":{"description":"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.Capabilities"},"privileged":{"description":"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"procMount":{"description":"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"readOnlyRootFilesystem":{"description":"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Capabilities":{"description":"Adds and removes POSIX capabilities from running containers.","properties":{"add":{"description":"Added capabilities","type":"array","items":{"type":"string"}},"drop":{"description":"Removed capabilities","type":"array","items":{"type":"string"}}}},"v1.SELinuxOptions":{"description":"SELinuxOptions are the labels to be applied to the container","properties":{"level":{"description":"Level is SELinux level label that applies to the container.","type":"string"},"role":{"description":"Role is a SELinux role label that applies to the container.","type":"string"},"type":{"description":"Type is a SELinux type label that applies to the container.","type":"string"},"user":{"description":"User is a SELinux user label that applies to the container.","type":"string"}}},"v1.SeccompProfile":{"description":"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.","required":["type"],"properties":{"localhostProfile":{"description":"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is \"Localhost\".","type":"string"},"type":{"description":"type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.","type":"string"}}},"v1.WindowsSecurityContextOptions":{"description":"WindowsSecurityContextOptions contain Windows-specific options and credentials.","properties":{"gmsaCredentialSpec":{"description":"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.","type":"string"},"gmsaCredentialSpecName":{"description":"GMSACredentialSpecName is the name of the GMSA credential spec to use.","type":"string"},"hostProcess":{"description":"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.","type":"boolean"},"runAsUserName":{"description":"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"string"}}},"v1.VolumeDevice":{"description":"volumeDevice describes a mapping of a raw block device within a container.","required":["name","devicePath"],"properties":{"devicePath":{"description":"devicePath is the path inside of the container that the device will be mapped to.","type":"string"},"name":{"description":"name must match the name of a persistentVolumeClaim in the pod","type":"string"}}},"v1.VolumeMount":{"description":"VolumeMount describes a mounting of a Volume within a container.","required":["name","mountPath"],"properties":{"mountPath":{"description":"Path within the container at which the volume should be mounted. Must not contain ':'.","type":"string"},"mountPropagation":{"description":"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10.","type":"string"},"name":{"description":"This must match the Name of a Volume.","type":"string"},"readOnly":{"description":"Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.","type":"boolean"},"subPath":{"description":"Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).","type":"string"},"subPathExpr":{"description":"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.","type":"string"}}},"v1alpha1.ContainerSetTemplate":{"required":["containers"],"properties":{"containers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ContainerNode"}},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.ContainerSetRetryStrategy"},"volumeMounts":{"type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}}}},"v1alpha1.ContainerNode":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"dependencies":{"type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.ContainerSetRetryStrategy":{"required":["retries"],"properties":{"duration":{"type":"string"},"retries":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"v1alpha1.DAGTemplate":{"required":["tasks"],"properties":{"failFast":{"type":"boolean"},"target":{"type":"string"},"tasks":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.DAGTask"}}}},"v1alpha1.DAGTask":{"required":["name"],"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"continueOn":{"$ref":"#/components/schemas/v1alpha1.ContinueOn"},"dependencies":{"type":"array","items":{"type":"string"}},"depends":{"type":"string"},"hooks":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LifecycleHook"}},"inline":{"$ref":"#/components/schemas/v1alpha1.Template"},"name":{"type":"string"},"onExit":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"},"when":{"type":"string"},"withItems":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Item"}},"withParam":{"type":"string"},"withSequence":{"$ref":"#/components/schemas/v1alpha1.Sequence"}}},"v1alpha1.Arguments":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Artifact":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.Parameter":{"required":["name"],"properties":{"default":{"type":"string"},"description":{"type":"string"},"enum":{"type":"array","items":{"type":"string"}},"globalName":{"type":"string"},"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.ValueFrom"}}},"v1alpha1.ValueFrom":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"default":{"type":"string"},"event":{"type":"string"},"expression":{"type":"string"},"jqFilter":{"type":"string"},"jsonPath":{"type":"string"},"parameter":{"type":"string"},"path":{"type":"string"},"supplied":{"$ref":"#/components/schemas/v1alpha1.SuppliedValueFrom"}}},"v1alpha1.SuppliedValueFrom":{},"v1alpha1.ContinueOn":{"properties":{"error":{"type":"boolean"},"failed":{"type":"boolean"}}},"v1alpha1.LifecycleHook":{"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"expression":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"}}},"v1alpha1.TemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"},"template":{"type":"string"}}},"v1alpha1.Data":{"required":["source","transformation"],"properties":{"source":{"$ref":"#/components/schemas/v1alpha1.DataSource"},"transformation":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.TransformationStep"}}}},"v1alpha1.DataSource":{"properties":{"artifactPaths":{"$ref":"#/components/schemas/v1alpha1.ArtifactPaths"}}},"v1alpha1.ArtifactPaths":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.TransformationStep":{"required":["expression"],"properties":{"expression":{"type":"string"}}},"v1alpha1.ExecutorConfig":{"properties":{"serviceAccountName":{"type":"string"}}},"v1.HostAlias":{"description":"HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.","properties":{"hostnames":{"description":"Hostnames for the above IP address.","type":"array","items":{"type":"string"}},"ip":{"description":"IP address of the host file entry.","type":"string"}}},"v1alpha1.HTTP":{"required":["url"],"properties":{"body":{"type":"string"},"bodyFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPBodySource"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.HTTPHeader"}},"insecureSkipVerify":{"type":"boolean"},"method":{"type":"string"},"successCondition":{"type":"string"},"timeoutSeconds":{"type":"integer","format":"int64"},"url":{"type":"string"}}},"v1alpha1.HTTPBodySource":{"properties":{"bytes":{"type":"string"}}},"v1alpha1.HTTPHeader":{"required":["name"],"properties":{"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPHeaderSource"}}},"v1alpha1.HTTPHeaderSource":{"properties":{"secretKeyRef":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.UserContainer":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"mirrorVolumeMounts":{"type":"boolean"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.Inputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Memoize":{"required":["key","cache","maxAge"],"properties":{"cache":{"$ref":"#/components/schemas/v1alpha1.Cache"},"key":{"type":"string"},"maxAge":{"type":"string"}}},"v1alpha1.Cache":{"required":["configMap"],"properties":{"configMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"}}},"v1alpha1.Metrics":{"required":["prometheus"],"properties":{"prometheus":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Prometheus"}}}},"v1alpha1.Prometheus":{"required":["name","help"],"properties":{"counter":{"$ref":"#/components/schemas/v1alpha1.Counter"},"gauge":{"$ref":"#/components/schemas/v1alpha1.Gauge"},"help":{"type":"string"},"histogram":{"$ref":"#/components/schemas/v1alpha1.Histogram"},"labels":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MetricLabel"}},"name":{"type":"string"},"when":{"type":"string"}}},"v1alpha1.Counter":{"required":["value"],"properties":{"value":{"type":"string"}}},"v1alpha1.Gauge":{"required":["value","realtime"],"properties":{"operation":{"type":"string"},"realtime":{"type":"boolean"},"value":{"type":"string"}}},"v1alpha1.Histogram":{"required":["value","buckets"],"properties":{"buckets":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Amount"}},"value":{"type":"string"}}},"v1alpha1.Amount":{},"v1alpha1.MetricLabel":{"required":["key","value"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Outputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"exitCode":{"type":"string"},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}},"result":{"type":"string"}}},"v1alpha1.Plugin":{},"v1alpha1.ResourceTemplate":{"required":["action"],"properties":{"action":{"type":"string"},"failureCondition":{"type":"string"},"flags":{"type":"array","items":{"type":"string"}},"manifest":{"type":"string"},"manifestFrom":{"$ref":"#/components/schemas/v1alpha1.ManifestFrom"},"mergeStrategy":{"type":"string"},"setOwnerReference":{"type":"boolean"},"successCondition":{"type":"string"}}},"v1alpha1.ManifestFrom":{"required":["artifact"],"properties":{"artifact":{"$ref":"#/components/schemas/v1alpha1.Artifact"}}},"v1alpha1.RetryStrategy":{"properties":{"affinity":{"$ref":"#/components/schemas/v1alpha1.RetryAffinity"},"backoff":{"$ref":"#/components/schemas/v1alpha1.Backoff"},"expression":{"type":"string"},"limit":{"$ref":"#/components/schemas/intstr.IntOrString"},"retryPolicy":{"type":"string"}}},"v1alpha1.RetryAffinity":{"properties":{"nodeAntiAffinity":{"$ref":"#/components/schemas/v1alpha1.RetryNodeAntiAffinity"}}},"v1alpha1.RetryNodeAntiAffinity":{},"v1alpha1.Backoff":{"properties":{"duration":{"type":"string"},"factor":{"$ref":"#/components/schemas/intstr.IntOrString"},"maxDuration":{"type":"string"}}},"v1alpha1.ScriptTemplate":{"description":"A single application container that you want to run within a pod.","required":["name","source"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"source":{"type":"string"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1.PodSecurityContext":{"description":"PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.","properties":{"fsGroup":{"description":"A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\n\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw ","type":"integer","format":"int64"},"fsGroupChangePolicy":{"description":"fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \"OnRootMismatch\" and \"Always\". If not specified, \"Always\" is used. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"supplementalGroups":{"description":"A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"type":"integer","format":"int64"}},"sysctls":{"description":"Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"$ref":"#/components/schemas/v1.Sysctl"}},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Sysctl":{"description":"Sysctl defines a kernel parameter to be set","required":["name","value"],"properties":{"name":{"description":"Name of a property to set","type":"string"},"value":{"description":"Value of a property to set","type":"string"}}},"v1alpha1.ParallelSteps":{},"v1alpha1.SuspendTemplate":{"properties":{"duration":{"type":"string"}}},"v1alpha1.Synchronization":{"properties":{"mutex":{"$ref":"#/components/schemas/v1alpha1.Mutex"},"semaphore":{"$ref":"#/components/schemas/v1alpha1.SemaphoreRef"}}},"v1alpha1.Mutex":{"properties":{"name":{"type":"string"},"namespace":{"type":"string"}}},"v1alpha1.SemaphoreRef":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"namespace":{"type":"string"}}},"v1.Toleration":{"description":"The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .","properties":{"effect":{"description":"Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.","type":"string"},"key":{"description":"Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.","type":"string"},"operator":{"description":"Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.","type":"string"},"tolerationSeconds":{"description":"TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.","type":"integer","format":"int64"},"value":{"description":"Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.","type":"string"}}},"v1.Volume":{"description":"Volume represents a named volume in a pod that may be accessed by any container in the pod.","required":["name"],"properties":{"awsElasticBlockStore":{"description":"awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","$ref":"#/components/schemas/v1.AWSElasticBlockStoreVolumeSource"},"azureDisk":{"description":"azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureDiskVolumeSource"},"azureFile":{"description":"azureFile represents an Azure File Service mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureFileVolumeSource"},"cephfs":{"description":"cephFS represents a Ceph FS mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.CephFSVolumeSource"},"cinder":{"description":"cinder represents a cinder volume attached and mounted on kubelets host machine. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","$ref":"#/components/schemas/v1.CinderVolumeSource"},"configMap":{"description":"configMap represents a configMap that should populate this volume","$ref":"#/components/schemas/v1.ConfigMapVolumeSource"},"csi":{"description":"csi (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers (Beta feature).","$ref":"#/components/schemas/v1.CSIVolumeSource"},"downwardAPI":{"description":"downwardAPI represents downward API about the pod that should populate this volume","$ref":"#/components/schemas/v1.DownwardAPIVolumeSource"},"emptyDir":{"description":"emptyDir represents a temporary directory that shares a pod's lifetime. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","$ref":"#/components/schemas/v1.EmptyDirVolumeSource"},"ephemeral":{"description":"ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed.\n\nUse this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity\n tracking are needed,\nc) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through\n a PersistentVolumeClaim (see EphemeralVolumeSource for more\n information on the connection between this volume type\n and PersistentVolumeClaim).\n\nUse PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod.\n\nUse CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information.\n\nA pod can use both types of ephemeral volumes and persistent volumes at the same time.","$ref":"#/components/schemas/v1.EphemeralVolumeSource"},"fc":{"description":"fc represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.","$ref":"#/components/schemas/v1.FCVolumeSource"},"flexVolume":{"description":"flexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","$ref":"#/components/schemas/v1.FlexVolumeSource"},"flocker":{"description":"flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running","$ref":"#/components/schemas/v1.FlockerVolumeSource"},"gcePersistentDisk":{"description":"gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","$ref":"#/components/schemas/v1.GCEPersistentDiskVolumeSource"},"gitRepo":{"description":"gitRepo represents a git repository at a particular revision. DEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","$ref":"#/components/schemas/v1.GitRepoVolumeSource"},"glusterfs":{"description":"glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/glusterfs/README.md","$ref":"#/components/schemas/v1.GlusterfsVolumeSource"},"hostPath":{"description":"hostPath represents a pre-existing file or directory on the host machine that is directly exposed to the container. This is generally used for system agents or other privileged things that are allowed to see the host machine. Most containers will NOT need this. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","$ref":"#/components/schemas/v1.HostPathVolumeSource"},"iscsi":{"description":"iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://examples.k8s.io/volumes/iscsi/README.md","$ref":"#/components/schemas/v1.ISCSIVolumeSource"},"name":{"description":"name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"nfs":{"description":"nfs represents an NFS mount on the host that shares a pod's lifetime More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","$ref":"#/components/schemas/v1.NFSVolumeSource"},"persistentVolumeClaim":{"description":"persistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimVolumeSource"},"photonPersistentDisk":{"description":"photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PhotonPersistentDiskVolumeSource"},"portworxVolume":{"description":"portworxVolume represents a portworx volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PortworxVolumeSource"},"projected":{"description":"projected items for all in one resources secrets, configmaps, and downward API","$ref":"#/components/schemas/v1.ProjectedVolumeSource"},"quobyte":{"description":"quobyte represents a Quobyte mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.QuobyteVolumeSource"},"rbd":{"description":"rbd represents a Rados Block Device mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/rbd/README.md","$ref":"#/components/schemas/v1.RBDVolumeSource"},"scaleIO":{"description":"scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.ScaleIOVolumeSource"},"secret":{"description":"secret represents a secret that should populate this volume. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","$ref":"#/components/schemas/v1.SecretVolumeSource"},"storageos":{"description":"storageOS represents a StorageOS volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.StorageOSVolumeSource"},"vsphereVolume":{"description":"vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.VsphereVirtualDiskVolumeSource"}}},"v1.AWSElasticBlockStoreVolumeSource":{"description":"Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).","type":"integer","format":"int32"},"readOnly":{"description":"readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"boolean"},"volumeID":{"description":"volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"}}},"v1.AzureDiskVolumeSource":{"description":"AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","required":["diskName","diskURI"],"properties":{"cachingMode":{"description":"cachingMode is the Host Caching mode: None, Read Only, Read Write.","type":"string"},"diskName":{"description":"diskName is the Name of the data disk in the blob storage","type":"string"},"diskURI":{"description":"diskURI is the URI of data disk in the blob storage","type":"string"},"fsType":{"description":"fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"kind":{"description":"kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"}}},"v1.AzureFileVolumeSource":{"description":"AzureFile represents an Azure File Service mount on the host and bind mount to the pod.","required":["secretName","shareName"],"properties":{"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretName":{"description":"secretName is the name of secret that contains Azure Storage Account Name and Key","type":"string"},"shareName":{"description":"shareName is the azure share Name","type":"string"}}},"v1.CephFSVolumeSource":{"description":"Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.","required":["monitors"],"properties":{"monitors":{"description":"monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"path":{"description":"path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /","type":"string"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"boolean"},"secretFile":{"description":"secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"},"secretRef":{"description":"secretRef is Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"}}},"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}},"v1.CinderVolumeSource":{"description":"Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"boolean"},"secretRef":{"description":"secretRef is optional: points to a secret object containing parameters used to connect to OpenStack.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeID":{"description":"volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"}}},"v1.ConfigMapVolumeSource":{"description":"Adapts a ConfigMap into a volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.KeyToPath":{"description":"Maps a string key to a path within a volume.","required":["key","path"],"properties":{"key":{"description":"key is the key to project.","type":"string"},"mode":{"description":"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.","type":"string"}}},"v1.CSIVolumeSource":{"description":"Represents a source location of a volume to mount, managed by an external CSI driver","required":["driver"],"properties":{"driver":{"description":"driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.","type":"string"},"fsType":{"description":"fsType to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.","type":"string"},"nodePublishSecretRef":{"description":"nodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secret references are passed.","$ref":"#/components/schemas/v1.LocalObjectReference"},"readOnly":{"description":"readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).","type":"boolean"},"volumeAttributes":{"description":"volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.","type":"object","additionalProperties":{"type":"string"}}}},"v1.DownwardAPIVolumeSource":{"description":"DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"Items is a list of downward API volume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.DownwardAPIVolumeFile":{"description":"DownwardAPIVolumeFile represents information to create the file containing the pod field","required":["path"],"properties":{"fieldRef":{"description":"Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"mode":{"description":"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'","type":"string"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"}}},"v1.EmptyDirVolumeSource":{"description":"Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.","properties":{"medium":{"description":"medium represents what type of storage medium should back this directory. The default is \"\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","type":"string"},"sizeLimit":{"description":"sizeLimit is the total amount of local storage required for this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. The default is nil which means that the limit is undefined. More info: http://kubernetes.io/docs/user-guide/volumes#emptydir","$ref":"#/components/schemas/resource.Quantity"}}},"v1.EphemeralVolumeSource":{"description":"Represents an ephemeral volume that is handled by a normal storage driver.","properties":{"volumeClaimTemplate":{"description":"Will be used to create a stand-alone PVC to provision the volume. The pod in which this EphemeralVolumeSource is embedded will be the owner of the PVC, i.e. the PVC will be deleted together with the pod. The name of the PVC will be `-` where `` is the name from the `PodSpec.Volumes` array entry. Pod validation will reject the pod if the concatenated name is not valid for a PVC (for example, too long).\n\nAn existing PVC with that name that is not owned by the pod will *not* be used for the pod to avoid using an unrelated volume by mistake. Starting the pod is then blocked until the unrelated PVC is removed. If such a pre-created PVC is meant to be used by the pod, the PVC has to updated with an owner reference to the pod once the pod exists. Normally this should not be necessary, but it may be useful when manually reconstructing a broken cluster.\n\nThis field is read-only and no changes will be made by Kubernetes to the PVC after it has been created.\n\nRequired, must not be nil.","$ref":"#/components/schemas/v1.PersistentVolumeClaimTemplate"}}},"v1.PersistentVolumeClaimTemplate":{"description":"PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.","required":["spec"],"properties":{"metadata":{"description":"May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"The specification for the PersistentVolumeClaim. The entire content is copied unchanged into the PVC that gets created from this template. The same fields as in a PersistentVolumeClaim are also valid here.","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"}}},"v1.ObjectMeta":{"description":"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.","properties":{"annotations":{"description":"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations","type":"object","additionalProperties":{"type":"string"}},"clusterName":{"description":"Deprecated: ClusterName is a legacy field that was always cleared by the system and never used; it will be removed completely in 1.25.\n\nThe name in the go struct is changed to help clients detect accidental use.","type":"string"},"creationTimestamp":{"description":"CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"deletionGracePeriodSeconds":{"description":"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.","type":"integer","format":"int64"},"deletionTimestamp":{"description":"DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"finalizers":{"description":"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.","type":"array","items":{"type":"string"}},"generateName":{"description":"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency","type":"string"},"generation":{"description":"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.","type":"integer","format":"int64"},"labels":{"description":"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels","type":"object","additionalProperties":{"type":"string"}},"managedFields":{"description":"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.","type":"array","items":{"$ref":"#/components/schemas/v1.ManagedFieldsEntry"}},"name":{"description":"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"namespace":{"description":"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces","type":"string"},"ownerReferences":{"description":"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.","type":"array","items":{"$ref":"#/components/schemas/v1.OwnerReference"}},"resourceVersion":{"description":"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency","type":"string"},"selfLink":{"description":"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.","type":"string"},"uid":{"description":"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}},"v1.ManagedFieldsEntry":{"description":"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.","properties":{"apiVersion":{"description":"APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.","type":"string"},"fieldsType":{"description":"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"","type":"string"},"fieldsV1":{"description":"FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type.","$ref":"#/components/schemas/v1.FieldsV1"},"manager":{"description":"Manager is an identifier of the workflow managing these fields.","type":"string"},"operation":{"description":"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.","type":"string"},"subresource":{"description":"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.","type":"string"},"time":{"description":"Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over.","$ref":"#/components/schemas/v1.Time"}}},"v1.FieldsV1":{"description":"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff"},"v1.OwnerReference":{"description":"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.","required":["apiVersion","kind","name","uid"],"properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"blockOwnerDeletion":{"description":"If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.","type":"boolean"},"controller":{"description":"If true, this reference points to the managing controller.","type":"boolean"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"uid":{"description":"UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.PersistentVolumeClaimSpec":{"description":"PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes","properties":{"accessModes":{"description":"accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"dataSource":{"description":"dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"dataSourceRef":{"description":"dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"resources":{"description":"resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources","$ref":"#/components/schemas/v1.ResourceRequirements"},"selector":{"description":"selector is a label query over volumes to consider for binding.","$ref":"#/components/schemas/v1.LabelSelector"},"storageClassName":{"description":"storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1","type":"string"},"volumeMode":{"description":"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.","type":"string"},"volumeName":{"description":"volumeName is the binding reference to the PersistentVolume backing this claim.","type":"string"}}},"v1.TypedLocalObjectReference":{"description":"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.","required":["apiGroup","kind","name"],"properties":{"apiGroup":{"description":"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.","type":"string"},"kind":{"description":"Kind is the type of resource being referenced","type":"string"},"name":{"description":"Name is the name of resource being referenced","type":"string"}}},"v1.FCVolumeSource":{"description":"Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"lun":{"description":"lun is Optional: FC target lun number","type":"integer","format":"int32"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"targetWWNs":{"description":"targetWWNs is Optional: FC target worldwide names (WWNs)","type":"array","items":{"type":"string"}},"wwids":{"description":"wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.","type":"array","items":{"type":"string"}}}},"v1.FlexVolumeSource":{"description":"FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","required":["driver"],"properties":{"driver":{"description":"driver is the name of the driver to use for this volume.","type":"string"},"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.","type":"string"},"options":{"description":"options is Optional: this field holds extra command options if any.","type":"object","additionalProperties":{"type":"string"}},"readOnly":{"description":"readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef is Optional: secretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts.","$ref":"#/components/schemas/v1.LocalObjectReference"}}},"v1.FlockerVolumeSource":{"description":"Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.","properties":{"datasetName":{"description":"datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated","type":"string"},"datasetUUID":{"description":"datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset","type":"string"}}},"v1.GCEPersistentDiskVolumeSource":{"description":"Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.","required":["pdName"],"properties":{"fsType":{"description":"fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"integer","format":"int32"},"pdName":{"description":"pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"boolean"}}},"v1.GitRepoVolumeSource":{"description":"Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","required":["repository"],"properties":{"directory":{"description":"directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.","type":"string"},"repository":{"description":"repository is the URL","type":"string"},"revision":{"description":"revision is the commit hash for the specified revision.","type":"string"}}},"v1.GlusterfsVolumeSource":{"description":"Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.","required":["endpoints","path"],"properties":{"endpoints":{"description":"endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"path":{"description":"path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"readOnly":{"description":"readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"boolean"}}},"v1.HostPathVolumeSource":{"description":"Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.","required":["path"],"properties":{"path":{"description":"path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"},"type":{"description":"type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"}}},"v1.ISCSIVolumeSource":{"description":"Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.","required":["targetPortal","iqn","lun"],"properties":{"chapAuthDiscovery":{"description":"chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication","type":"boolean"},"chapAuthSession":{"description":"chapAuthSession defines whether support iSCSI Session CHAP authentication","type":"boolean"},"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi","type":"string"},"initiatorName":{"description":"initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.","type":"string"},"iqn":{"description":"iqn is the target iSCSI Qualified Name.","type":"string"},"iscsiInterface":{"description":"iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).","type":"string"},"lun":{"description":"lun represents iSCSI Target Lun number.","type":"integer","format":"int32"},"portals":{"description":"portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"array","items":{"type":"string"}},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.","type":"boolean"},"secretRef":{"description":"secretRef is the CHAP Secret for iSCSI target and initiator authentication","$ref":"#/components/schemas/v1.LocalObjectReference"},"targetPortal":{"description":"targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"string"}}},"v1.NFSVolumeSource":{"description":"Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.","required":["server","path"],"properties":{"path":{"description":"path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"},"readOnly":{"description":"readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"boolean"},"server":{"description":"server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"}}},"v1.PersistentVolumeClaimVolumeSource":{"description":"PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).","required":["claimName"],"properties":{"claimName":{"description":"claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","type":"string"},"readOnly":{"description":"readOnly Will force the ReadOnly setting in VolumeMounts. Default false.","type":"boolean"}}},"v1.PhotonPersistentDiskVolumeSource":{"description":"Represents a Photon Controller persistent disk resource.","required":["pdID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"pdID":{"description":"pdID is the ID that identifies Photon Controller persistent disk","type":"string"}}},"v1.PortworxVolumeSource":{"description":"PortworxVolumeSource represents a Portworx volume resource.","required":["volumeID"],"properties":{"fsType":{"description":"fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"volumeID":{"description":"volumeID uniquely identifies a Portworx volume","type":"string"}}},"v1.ProjectedVolumeSource":{"description":"Represents a projected volume source","required":["sources"],"properties":{"defaultMode":{"description":"defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"sources":{"description":"sources is the list of volume projections","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeProjection"}}}},"v1.VolumeProjection":{"description":"Projection that may be projected along with other supported volume types","properties":{"configMap":{"description":"configMap information about the configMap data to project","$ref":"#/components/schemas/v1.ConfigMapProjection"},"downwardAPI":{"description":"downwardAPI information about the downwardAPI data to project","$ref":"#/components/schemas/v1.DownwardAPIProjection"},"secret":{"description":"secret information about the secret data to project","$ref":"#/components/schemas/v1.SecretProjection"},"serviceAccountToken":{"description":"serviceAccountToken is information about the serviceAccountToken data to project","$ref":"#/components/schemas/v1.ServiceAccountTokenProjection"}}},"v1.ConfigMapProjection":{"description":"Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.DownwardAPIProjection":{"description":"Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.","properties":{"items":{"description":"Items is a list of DownwardAPIVolume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.SecretProjection":{"description":"Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional field specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.ServiceAccountTokenProjection":{"description":"ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).","required":["path"],"properties":{"audience":{"description":"audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.","type":"string"},"expirationSeconds":{"description":"expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.","type":"integer","format":"int64"},"path":{"description":"path is the path relative to the mount point of the file to project the token into.","type":"string"}}},"v1.QuobyteVolumeSource":{"description":"Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.","required":["registry","volume"],"properties":{"group":{"description":"group to map volume access to Default is no group","type":"string"},"readOnly":{"description":"readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.","type":"boolean"},"registry":{"description":"registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes","type":"string"},"tenant":{"description":"tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin","type":"string"},"user":{"description":"user to map volume access to Defaults to serivceaccount user","type":"string"},"volume":{"description":"volume is a string that references an already created Quobyte volume by name.","type":"string"}}},"v1.RBDVolumeSource":{"description":"Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.","required":["monitors","image"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd","type":"string"},"image":{"description":"image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"keyring":{"description":"keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"monitors":{"description":"monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"pool":{"description":"pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"boolean"},"secretRef":{"description":"secretRef is name of the authentication secret for RBDUser. If provided overrides keyring. Default is nil. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"}}},"v1.ScaleIOVolumeSource":{"description":"ScaleIOVolumeSource represents a persistent ScaleIO volume","required":["gateway","system","secretRef"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\".","type":"string"},"gateway":{"description":"gateway is the host address of the ScaleIO API Gateway.","type":"string"},"protectionDomain":{"description":"protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef references to the secret for ScaleIO user and other sensitive information. If this is not provided, Login operation will fail.","$ref":"#/components/schemas/v1.LocalObjectReference"},"sslEnabled":{"description":"sslEnabled Flag enable/disable SSL communication with Gateway, default false","type":"boolean"},"storageMode":{"description":"storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.","type":"string"},"storagePool":{"description":"storagePool is the ScaleIO Storage Pool associated with the protection domain.","type":"string"},"system":{"description":"system is the name of the storage system as configured in ScaleIO.","type":"string"},"volumeName":{"description":"volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.","type":"string"}}},"v1.SecretVolumeSource":{"description":"Adapts a Secret into a volume.\n\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"optional":{"description":"optional field specify whether the Secret or its keys must be defined","type":"boolean"},"secretName":{"description":"secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","type":"string"}}},"v1.StorageOSVolumeSource":{"description":"Represents a StorageOS persistent volume resource.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeName":{"description":"volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.","type":"string"},"volumeNamespace":{"description":"volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.","type":"string"}}},"v1.VsphereVirtualDiskVolumeSource":{"description":"Represents a vSphere volume resource.","required":["volumePath"],"properties":{"fsType":{"description":"fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"storagePolicyID":{"description":"storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.","type":"string"},"storagePolicyName":{"description":"storagePolicyName is the storage Policy Based Management (SPBM) profile name.","type":"string"},"volumePath":{"description":"volumePath is the path that identifies vSphere volume vmdk","type":"string"}}},"v1alpha1.Item":{},"v1alpha1.Sequence":{"properties":{"count":{"$ref":"#/components/schemas/intstr.IntOrString"},"end":{"$ref":"#/components/schemas/intstr.IntOrString"},"format":{"type":"string"},"start":{"$ref":"#/components/schemas/intstr.IntOrString"}}}}}} ``` ## The v1alpha1.TemplateRef object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.TemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"},"template":{"type":"string"}}}}}} ``` ## The v1alpha1.TransformationStep object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.TransformationStep":{"required":["expression"],"properties":{"expression":{"type":"string"}}}}}} ``` ## The v1alpha1.UserContainer object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.UserContainer":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"mirrorVolumeMounts":{"type":"boolean"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1.EnvVar":{"description":"EnvVar represents an environment variable present in a Container.","required":["name"],"properties":{"name":{"description":"Name of the environment variable. Must be a C_IDENTIFIER.","type":"string"},"value":{"description":"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".","type":"string"},"valueFrom":{"description":"Source for the environment variable's value. Cannot be used if value is not empty.","$ref":"#/components/schemas/v1.EnvVarSource"}}},"v1.EnvVarSource":{"description":"EnvVarSource represents a source for the value of an EnvVar.","properties":{"configMapKeyRef":{"description":"Selects a key of a ConfigMap.","$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"fieldRef":{"description":"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"},"secretKeyRef":{"description":"Selects a key of a secret in the pod's namespace","$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.EnvFromSource":{"description":"EnvFromSource represents the source of a set of ConfigMaps","properties":{"configMapRef":{"description":"The ConfigMap to select from","$ref":"#/components/schemas/v1.ConfigMapEnvSource"},"prefix":{"description":"An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.","type":"string"},"secretRef":{"description":"The Secret to select from","$ref":"#/components/schemas/v1.SecretEnvSource"}}},"v1.ConfigMapEnvSource":{"description":"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap must be defined","type":"boolean"}}},"v1.SecretEnvSource":{"description":"SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret must be defined","type":"boolean"}}},"v1.Lifecycle":{"description":"Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.","properties":{"postStart":{"description":"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"},"preStop":{"description":"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"}}},"v1.LifecycleHandler":{"description":"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"tcpSocket":{"description":"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.","$ref":"#/components/schemas/v1.TCPSocketAction"}}},"v1.ExecAction":{"description":"ExecAction describes a \"run in container\" action.","properties":{"command":{"description":"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.","type":"array","items":{"type":"string"}}}},"v1.HTTPGetAction":{"description":"HTTPGetAction describes an action based on HTTP Get requests.","required":["port"],"properties":{"host":{"description":"Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.","type":"string"},"httpHeaders":{"description":"Custom headers to set in the request. HTTP allows repeated headers.","type":"array","items":{"$ref":"#/components/schemas/v1.HTTPHeader"}},"path":{"description":"Path to access on the HTTP server.","type":"string"},"port":{"description":"Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"},"scheme":{"description":"Scheme to use for connecting to the host. Defaults to HTTP.","type":"string"}}},"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}},"v1.TCPSocketAction":{"description":"TCPSocketAction describes an action based on opening a socket","required":["port"],"properties":{"host":{"description":"Optional: Host name to connect to, defaults to the pod IP.","type":"string"},"port":{"description":"Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"}}},"v1.Probe":{"description":"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"failureThreshold":{"description":"Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.","type":"integer","format":"int32"},"grpc":{"description":"GRPC specifies an action involving a GRPC port. This is a beta field and requires enabling GRPCContainerProbe feature gate.","$ref":"#/components/schemas/v1.GRPCAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"initialDelaySeconds":{"description":"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"},"periodSeconds":{"description":"How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.","type":"integer","format":"int32"},"successThreshold":{"description":"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.","type":"integer","format":"int32"},"tcpSocket":{"description":"TCPSocket specifies an action involving a TCP port.","$ref":"#/components/schemas/v1.TCPSocketAction"},"terminationGracePeriodSeconds":{"description":"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.","type":"integer","format":"int64"},"timeoutSeconds":{"description":"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"}}},"v1.GRPCAction":{"required":["port","service"],"properties":{"port":{"description":"Port number of the gRPC service. Number must be in the range 1 to 65535.","type":"integer","format":"int32"},"service":{"description":"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.","type":"string"}}},"v1.ContainerPort":{"description":"ContainerPort represents a network port in a single container.","required":["containerPort"],"properties":{"containerPort":{"description":"Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.","type":"integer","format":"int32"},"hostIP":{"description":"What host IP to bind the external port to.","type":"string"},"hostPort":{"description":"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.","type":"integer","format":"int32"},"name":{"description":"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.","type":"string"},"protocol":{"description":"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"v1.SecurityContext":{"description":"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.","properties":{"allowPrivilegeEscalation":{"description":"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"capabilities":{"description":"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.Capabilities"},"privileged":{"description":"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"procMount":{"description":"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"readOnlyRootFilesystem":{"description":"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Capabilities":{"description":"Adds and removes POSIX capabilities from running containers.","properties":{"add":{"description":"Added capabilities","type":"array","items":{"type":"string"}},"drop":{"description":"Removed capabilities","type":"array","items":{"type":"string"}}}},"v1.SELinuxOptions":{"description":"SELinuxOptions are the labels to be applied to the container","properties":{"level":{"description":"Level is SELinux level label that applies to the container.","type":"string"},"role":{"description":"Role is a SELinux role label that applies to the container.","type":"string"},"type":{"description":"Type is a SELinux type label that applies to the container.","type":"string"},"user":{"description":"User is a SELinux user label that applies to the container.","type":"string"}}},"v1.SeccompProfile":{"description":"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.","required":["type"],"properties":{"localhostProfile":{"description":"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is \"Localhost\".","type":"string"},"type":{"description":"type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.","type":"string"}}},"v1.WindowsSecurityContextOptions":{"description":"WindowsSecurityContextOptions contain Windows-specific options and credentials.","properties":{"gmsaCredentialSpec":{"description":"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.","type":"string"},"gmsaCredentialSpecName":{"description":"GMSACredentialSpecName is the name of the GMSA credential spec to use.","type":"string"},"hostProcess":{"description":"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.","type":"boolean"},"runAsUserName":{"description":"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"string"}}},"v1.VolumeDevice":{"description":"volumeDevice describes a mapping of a raw block device within a container.","required":["name","devicePath"],"properties":{"devicePath":{"description":"devicePath is the path inside of the container that the device will be mapped to.","type":"string"},"name":{"description":"name must match the name of a persistentVolumeClaim in the pod","type":"string"}}},"v1.VolumeMount":{"description":"VolumeMount describes a mounting of a Volume within a container.","required":["name","mountPath"],"properties":{"mountPath":{"description":"Path within the container at which the volume should be mounted. Must not contain ':'.","type":"string"},"mountPropagation":{"description":"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10.","type":"string"},"name":{"description":"This must match the Name of a Volume.","type":"string"},"readOnly":{"description":"Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.","type":"boolean"},"subPath":{"description":"Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).","type":"string"},"subPathExpr":{"description":"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.","type":"string"}}}}}} ``` ## The v1alpha1.ValueFrom object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ValueFrom":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"default":{"type":"string"},"event":{"type":"string"},"expression":{"type":"string"},"jqFilter":{"type":"string"},"jsonPath":{"type":"string"},"parameter":{"type":"string"},"path":{"type":"string"},"supplied":{"$ref":"#/components/schemas/v1alpha1.SuppliedValueFrom"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.SuppliedValueFrom":{}}}} ``` ## The v1alpha1.VolumeClaimGC object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.VolumeClaimGC":{"properties":{"strategy":{"type":"string"}}}}}} ``` ## The v1alpha1.Workflow object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.Workflow":{"required":["metadata","spec"],"properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"$ref":"#/components/schemas/v1alpha1.WorkflowSpec"},"status":{"$ref":"#/components/schemas/v1alpha1.WorkflowStatus"}}},"v1.ObjectMeta":{"description":"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.","properties":{"annotations":{"description":"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations","type":"object","additionalProperties":{"type":"string"}},"clusterName":{"description":"Deprecated: ClusterName is a legacy field that was always cleared by the system and never used; it will be removed completely in 1.25.\n\nThe name in the go struct is changed to help clients detect accidental use.","type":"string"},"creationTimestamp":{"description":"CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"deletionGracePeriodSeconds":{"description":"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.","type":"integer","format":"int64"},"deletionTimestamp":{"description":"DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"finalizers":{"description":"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.","type":"array","items":{"type":"string"}},"generateName":{"description":"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency","type":"string"},"generation":{"description":"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.","type":"integer","format":"int64"},"labels":{"description":"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels","type":"object","additionalProperties":{"type":"string"}},"managedFields":{"description":"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.","type":"array","items":{"$ref":"#/components/schemas/v1.ManagedFieldsEntry"}},"name":{"description":"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"namespace":{"description":"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces","type":"string"},"ownerReferences":{"description":"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.","type":"array","items":{"$ref":"#/components/schemas/v1.OwnerReference"}},"resourceVersion":{"description":"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency","type":"string"},"selfLink":{"description":"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.","type":"string"},"uid":{"description":"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}},"v1.ManagedFieldsEntry":{"description":"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.","properties":{"apiVersion":{"description":"APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.","type":"string"},"fieldsType":{"description":"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"","type":"string"},"fieldsV1":{"description":"FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type.","$ref":"#/components/schemas/v1.FieldsV1"},"manager":{"description":"Manager is an identifier of the workflow managing these fields.","type":"string"},"operation":{"description":"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.","type":"string"},"subresource":{"description":"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.","type":"string"},"time":{"description":"Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over.","$ref":"#/components/schemas/v1.Time"}}},"v1.FieldsV1":{"description":"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff"},"v1.OwnerReference":{"description":"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.","required":["apiVersion","kind","name","uid"],"properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"blockOwnerDeletion":{"description":"If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.","type":"boolean"},"controller":{"description":"If true, this reference points to the managing controller.","type":"boolean"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"uid":{"description":"UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1alpha1.WorkflowSpec":{"properties":{"activeDeadlineSeconds":{"type":"integer","format":"int64"},"affinity":{"$ref":"#/components/schemas/v1.Affinity"},"archiveLogs":{"type":"boolean"},"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.WorkflowLevelArtifactGC"},"artifactRepositoryRef":{"$ref":"#/components/schemas/v1alpha1.ArtifactRepositoryRef"},"automountServiceAccountToken":{"type":"boolean"},"dnsConfig":{"$ref":"#/components/schemas/v1.PodDNSConfig"},"dnsPolicy":{"type":"string"},"entrypoint":{"type":"string"},"executor":{"$ref":"#/components/schemas/v1alpha1.ExecutorConfig"},"hooks":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LifecycleHook"}},"hostAliases":{"type":"array","items":{"$ref":"#/components/schemas/v1.HostAlias"}},"hostNetwork":{"type":"boolean"},"imagePullSecrets":{"type":"array","items":{"$ref":"#/components/schemas/v1.LocalObjectReference"}},"metrics":{"$ref":"#/components/schemas/v1alpha1.Metrics"},"nodeSelector":{"type":"object","additionalProperties":{"type":"string"}},"onExit":{"type":"string"},"parallelism":{"type":"integer","format":"int64"},"podDisruptionBudget":{"$ref":"#/components/schemas/v1.PodDisruptionBudgetSpec"},"podGC":{"$ref":"#/components/schemas/v1alpha1.PodGC"},"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"podPriority":{"type":"integer","format":"int32"},"podPriorityClassName":{"type":"string"},"podSpecPatch":{"type":"string"},"priority":{"type":"integer","format":"int32"},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.RetryStrategy"},"schedulerName":{"type":"string"},"securityContext":{"$ref":"#/components/schemas/v1.PodSecurityContext"},"serviceAccountName":{"type":"string"},"shutdown":{"type":"string"},"suspend":{"type":"boolean"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.Synchronization"},"templateDefaults":{"$ref":"#/components/schemas/v1alpha1.Template"},"templates":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Template"}},"tolerations":{"type":"array","items":{"$ref":"#/components/schemas/v1.Toleration"}},"ttlStrategy":{"$ref":"#/components/schemas/v1alpha1.TTLStrategy"},"volumeClaimGC":{"$ref":"#/components/schemas/v1alpha1.VolumeClaimGC"},"volumeClaimTemplates":{"type":"array","items":{"$ref":"#/components/schemas/v1.PersistentVolumeClaim"}},"volumes":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}},"workflowMetadata":{"$ref":"#/components/schemas/v1alpha1.WorkflowMetadata"},"workflowTemplateRef":{"$ref":"#/components/schemas/v1alpha1.WorkflowTemplateRef"}}},"v1.Affinity":{"description":"Affinity is a group of affinity scheduling rules.","properties":{"nodeAffinity":{"description":"Describes node affinity scheduling rules for the pod.","$ref":"#/components/schemas/v1.NodeAffinity"},"podAffinity":{"description":"Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAffinity"},"podAntiAffinity":{"description":"Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAntiAffinity"}}},"v1.NodeAffinity":{"description":"Node affinity is a group of node affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.PreferredSchedulingTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.","$ref":"#/components/schemas/v1.NodeSelector"}}},"v1.PreferredSchedulingTerm":{"description":"An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).","required":["weight","preference"],"properties":{"preference":{"description":"A node selector term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.NodeSelectorTerm"},"weight":{"description":"Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.NodeSelectorTerm":{"description":"A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.","properties":{"matchExpressions":{"description":"A list of node selector requirements by node's labels.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}},"matchFields":{"description":"A list of node selector requirements by node's fields.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}}}},"v1.NodeSelectorRequirement":{"description":"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"The label key that the selector applies to.","type":"string"},"operator":{"description":"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.","type":"string"},"values":{"description":"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.NodeSelector":{"description":"A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.","required":["nodeSelectorTerms"],"properties":{"nodeSelectorTerms":{"description":"Required. A list of node selector terms. The terms are ORed.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorTerm"}}}},"v1.PodAffinity":{"description":"Pod affinity is a group of inter pod affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1.WeightedPodAffinityTerm":{"description":"The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)","required":["weight","podAffinityTerm"],"properties":{"podAffinityTerm":{"description":"Required. A pod affinity term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.PodAffinityTerm"},"weight":{"description":"weight associated with matching the corresponding podAffinityTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.PodAffinityTerm":{"description":"Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running","required":["topologyKey"],"properties":{"labelSelector":{"description":"A label query over a set of resources, in this case pods.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaceSelector":{"description":"A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means \"this pod's namespace\". An empty selector ({}) matches all namespaces.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaces":{"description":"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".","type":"array","items":{"type":"string"}},"topologyKey":{"description":"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.","type":"string"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.PodAntiAffinity":{"description":"Pod anti affinity is a group of inter pod anti affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1alpha1.Arguments":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Artifact":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.Parameter":{"required":["name"],"properties":{"default":{"type":"string"},"description":{"type":"string"},"enum":{"type":"array","items":{"type":"string"}},"globalName":{"type":"string"},"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.ValueFrom"}}},"v1alpha1.ValueFrom":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"default":{"type":"string"},"event":{"type":"string"},"expression":{"type":"string"},"jqFilter":{"type":"string"},"jsonPath":{"type":"string"},"parameter":{"type":"string"},"path":{"type":"string"},"supplied":{"$ref":"#/components/schemas/v1alpha1.SuppliedValueFrom"}}},"v1alpha1.SuppliedValueFrom":{},"v1alpha1.WorkflowLevelArtifactGC":{"properties":{"forceFinalizerRemoval":{"type":"boolean"},"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"podSpecPatch":{"type":"string"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.ArtifactRepositoryRef":{"properties":{"configMap":{"type":"string"},"key":{"type":"string"}}},"v1.PodDNSConfig":{"description":"PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy.","properties":{"nameservers":{"description":"A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed.","type":"array","items":{"type":"string"}},"options":{"description":"A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy.","type":"array","items":{"$ref":"#/components/schemas/v1.PodDNSConfigOption"}},"searches":{"description":"A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed.","type":"array","items":{"type":"string"}}}},"v1.PodDNSConfigOption":{"description":"PodDNSConfigOption defines DNS resolver options of a pod.","properties":{"name":{"description":"Required.","type":"string"},"value":{"type":"string"}}},"v1alpha1.ExecutorConfig":{"properties":{"serviceAccountName":{"type":"string"}}},"v1alpha1.LifecycleHook":{"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"expression":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"}}},"v1alpha1.TemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"},"template":{"type":"string"}}},"v1.HostAlias":{"description":"HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.","properties":{"hostnames":{"description":"Hostnames for the above IP address.","type":"array","items":{"type":"string"}},"ip":{"description":"IP address of the host file entry.","type":"string"}}},"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}},"v1alpha1.Metrics":{"required":["prometheus"],"properties":{"prometheus":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Prometheus"}}}},"v1alpha1.Prometheus":{"required":["name","help"],"properties":{"counter":{"$ref":"#/components/schemas/v1alpha1.Counter"},"gauge":{"$ref":"#/components/schemas/v1alpha1.Gauge"},"help":{"type":"string"},"histogram":{"$ref":"#/components/schemas/v1alpha1.Histogram"},"labels":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MetricLabel"}},"name":{"type":"string"},"when":{"type":"string"}}},"v1alpha1.Counter":{"required":["value"],"properties":{"value":{"type":"string"}}},"v1alpha1.Gauge":{"required":["value","realtime"],"properties":{"operation":{"type":"string"},"realtime":{"type":"boolean"},"value":{"type":"string"}}},"v1alpha1.Histogram":{"required":["value","buckets"],"properties":{"buckets":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Amount"}},"value":{"type":"string"}}},"v1alpha1.Amount":{},"v1alpha1.MetricLabel":{"required":["key","value"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1.PodDisruptionBudgetSpec":{"description":"PodDisruptionBudgetSpec is a description of a PodDisruptionBudget.","properties":{"maxUnavailable":{"description":"An eviction is allowed if at most \"maxUnavailable\" pods selected by \"selector\" are unavailable after the eviction, i.e. even in absence of the evicted pod. For example, one can prevent all voluntary evictions by specifying 0. This is a mutually exclusive setting with \"minAvailable\".","$ref":"#/components/schemas/intstr.IntOrString"},"minAvailable":{"description":"An eviction is allowed if at least \"minAvailable\" pods selected by \"selector\" will still be available after the eviction, i.e. even in the absence of the evicted pod. So for example you can prevent all voluntary evictions by specifying \"100%\".","$ref":"#/components/schemas/intstr.IntOrString"},"selector":{"description":"Label query over pods whose evictions are managed by the disruption budget. A null selector will match no pods, while an empty ({}) selector will select all pods within the namespace.","$ref":"#/components/schemas/v1.LabelSelector"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}},"v1alpha1.PodGC":{"properties":{"deleteDelayDuration":{"type":"string"},"labelSelector":{"$ref":"#/components/schemas/v1.LabelSelector"},"strategy":{"type":"string"}}},"v1alpha1.RetryStrategy":{"properties":{"affinity":{"$ref":"#/components/schemas/v1alpha1.RetryAffinity"},"backoff":{"$ref":"#/components/schemas/v1alpha1.Backoff"},"expression":{"type":"string"},"limit":{"$ref":"#/components/schemas/intstr.IntOrString"},"retryPolicy":{"type":"string"}}},"v1alpha1.RetryAffinity":{"properties":{"nodeAntiAffinity":{"$ref":"#/components/schemas/v1alpha1.RetryNodeAntiAffinity"}}},"v1alpha1.RetryNodeAntiAffinity":{},"v1alpha1.Backoff":{"properties":{"duration":{"type":"string"},"factor":{"$ref":"#/components/schemas/intstr.IntOrString"},"maxDuration":{"type":"string"}}},"v1.PodSecurityContext":{"description":"PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.","properties":{"fsGroup":{"description":"A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\n\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw ","type":"integer","format":"int64"},"fsGroupChangePolicy":{"description":"fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \"OnRootMismatch\" and \"Always\". If not specified, \"Always\" is used. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"supplementalGroups":{"description":"A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"type":"integer","format":"int64"}},"sysctls":{"description":"Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"$ref":"#/components/schemas/v1.Sysctl"}},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.SELinuxOptions":{"description":"SELinuxOptions are the labels to be applied to the container","properties":{"level":{"description":"Level is SELinux level label that applies to the container.","type":"string"},"role":{"description":"Role is a SELinux role label that applies to the container.","type":"string"},"type":{"description":"Type is a SELinux type label that applies to the container.","type":"string"},"user":{"description":"User is a SELinux user label that applies to the container.","type":"string"}}},"v1.SeccompProfile":{"description":"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.","required":["type"],"properties":{"localhostProfile":{"description":"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is \"Localhost\".","type":"string"},"type":{"description":"type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.","type":"string"}}},"v1.Sysctl":{"description":"Sysctl defines a kernel parameter to be set","required":["name","value"],"properties":{"name":{"description":"Name of a property to set","type":"string"},"value":{"description":"Value of a property to set","type":"string"}}},"v1.WindowsSecurityContextOptions":{"description":"WindowsSecurityContextOptions contain Windows-specific options and credentials.","properties":{"gmsaCredentialSpec":{"description":"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.","type":"string"},"gmsaCredentialSpecName":{"description":"GMSACredentialSpecName is the name of the GMSA credential spec to use.","type":"string"},"hostProcess":{"description":"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.","type":"boolean"},"runAsUserName":{"description":"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"string"}}},"v1alpha1.Synchronization":{"properties":{"mutex":{"$ref":"#/components/schemas/v1alpha1.Mutex"},"semaphore":{"$ref":"#/components/schemas/v1alpha1.SemaphoreRef"}}},"v1alpha1.Mutex":{"properties":{"name":{"type":"string"},"namespace":{"type":"string"}}},"v1alpha1.SemaphoreRef":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"namespace":{"type":"string"}}},"v1alpha1.Template":{"properties":{"activeDeadlineSeconds":{"$ref":"#/components/schemas/intstr.IntOrString"},"affinity":{"$ref":"#/components/schemas/v1.Affinity"},"archiveLocation":{"$ref":"#/components/schemas/v1alpha1.ArtifactLocation"},"automountServiceAccountToken":{"type":"boolean"},"container":{"$ref":"#/components/schemas/v1.Container"},"containerSet":{"$ref":"#/components/schemas/v1alpha1.ContainerSetTemplate"},"daemon":{"type":"boolean"},"dag":{"$ref":"#/components/schemas/v1alpha1.DAGTemplate"},"data":{"$ref":"#/components/schemas/v1alpha1.Data"},"executor":{"$ref":"#/components/schemas/v1alpha1.ExecutorConfig"},"failFast":{"type":"boolean"},"hostAliases":{"type":"array","items":{"$ref":"#/components/schemas/v1.HostAlias"}},"http":{"$ref":"#/components/schemas/v1alpha1.HTTP"},"initContainers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"inputs":{"$ref":"#/components/schemas/v1alpha1.Inputs"},"memoize":{"$ref":"#/components/schemas/v1alpha1.Memoize"},"metadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"metrics":{"$ref":"#/components/schemas/v1alpha1.Metrics"},"name":{"type":"string"},"nodeSelector":{"type":"object","additionalProperties":{"type":"string"}},"outputs":{"$ref":"#/components/schemas/v1alpha1.Outputs"},"parallelism":{"type":"integer","format":"int64"},"plugin":{"$ref":"#/components/schemas/v1alpha1.Plugin"},"podSpecPatch":{"type":"string"},"priority":{"type":"integer","format":"int32"},"priorityClassName":{"type":"string"},"resource":{"$ref":"#/components/schemas/v1alpha1.ResourceTemplate"},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.RetryStrategy"},"schedulerName":{"type":"string"},"script":{"$ref":"#/components/schemas/v1alpha1.ScriptTemplate"},"securityContext":{"$ref":"#/components/schemas/v1.PodSecurityContext"},"serviceAccountName":{"type":"string"},"sidecars":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"steps":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ParallelSteps"}},"suspend":{"$ref":"#/components/schemas/v1alpha1.SuspendTemplate"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.Synchronization"},"timeout":{"type":"string"},"tolerations":{"type":"array","items":{"$ref":"#/components/schemas/v1.Toleration"}},"volumes":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}}}},"v1alpha1.ArtifactLocation":{"properties":{"archiveLogs":{"type":"boolean"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"}}},"v1.Container":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1.EnvVar":{"description":"EnvVar represents an environment variable present in a Container.","required":["name"],"properties":{"name":{"description":"Name of the environment variable. Must be a C_IDENTIFIER.","type":"string"},"value":{"description":"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".","type":"string"},"valueFrom":{"description":"Source for the environment variable's value. Cannot be used if value is not empty.","$ref":"#/components/schemas/v1.EnvVarSource"}}},"v1.EnvVarSource":{"description":"EnvVarSource represents a source for the value of an EnvVar.","properties":{"configMapKeyRef":{"description":"Selects a key of a ConfigMap.","$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"fieldRef":{"description":"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"},"secretKeyRef":{"description":"Selects a key of a secret in the pod's namespace","$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.EnvFromSource":{"description":"EnvFromSource represents the source of a set of ConfigMaps","properties":{"configMapRef":{"description":"The ConfigMap to select from","$ref":"#/components/schemas/v1.ConfigMapEnvSource"},"prefix":{"description":"An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.","type":"string"},"secretRef":{"description":"The Secret to select from","$ref":"#/components/schemas/v1.SecretEnvSource"}}},"v1.ConfigMapEnvSource":{"description":"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap must be defined","type":"boolean"}}},"v1.SecretEnvSource":{"description":"SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret must be defined","type":"boolean"}}},"v1.Lifecycle":{"description":"Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.","properties":{"postStart":{"description":"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"},"preStop":{"description":"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"}}},"v1.LifecycleHandler":{"description":"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"tcpSocket":{"description":"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.","$ref":"#/components/schemas/v1.TCPSocketAction"}}},"v1.ExecAction":{"description":"ExecAction describes a \"run in container\" action.","properties":{"command":{"description":"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.","type":"array","items":{"type":"string"}}}},"v1.HTTPGetAction":{"description":"HTTPGetAction describes an action based on HTTP Get requests.","required":["port"],"properties":{"host":{"description":"Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.","type":"string"},"httpHeaders":{"description":"Custom headers to set in the request. HTTP allows repeated headers.","type":"array","items":{"$ref":"#/components/schemas/v1.HTTPHeader"}},"path":{"description":"Path to access on the HTTP server.","type":"string"},"port":{"description":"Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"},"scheme":{"description":"Scheme to use for connecting to the host. Defaults to HTTP.","type":"string"}}},"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}},"v1.TCPSocketAction":{"description":"TCPSocketAction describes an action based on opening a socket","required":["port"],"properties":{"host":{"description":"Optional: Host name to connect to, defaults to the pod IP.","type":"string"},"port":{"description":"Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"}}},"v1.Probe":{"description":"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"failureThreshold":{"description":"Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.","type":"integer","format":"int32"},"grpc":{"description":"GRPC specifies an action involving a GRPC port. This is a beta field and requires enabling GRPCContainerProbe feature gate.","$ref":"#/components/schemas/v1.GRPCAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"initialDelaySeconds":{"description":"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"},"periodSeconds":{"description":"How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.","type":"integer","format":"int32"},"successThreshold":{"description":"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.","type":"integer","format":"int32"},"tcpSocket":{"description":"TCPSocket specifies an action involving a TCP port.","$ref":"#/components/schemas/v1.TCPSocketAction"},"terminationGracePeriodSeconds":{"description":"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.","type":"integer","format":"int64"},"timeoutSeconds":{"description":"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"}}},"v1.GRPCAction":{"required":["port","service"],"properties":{"port":{"description":"Port number of the gRPC service. Number must be in the range 1 to 65535.","type":"integer","format":"int32"},"service":{"description":"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.","type":"string"}}},"v1.ContainerPort":{"description":"ContainerPort represents a network port in a single container.","required":["containerPort"],"properties":{"containerPort":{"description":"Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.","type":"integer","format":"int32"},"hostIP":{"description":"What host IP to bind the external port to.","type":"string"},"hostPort":{"description":"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.","type":"integer","format":"int32"},"name":{"description":"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.","type":"string"},"protocol":{"description":"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"v1.SecurityContext":{"description":"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.","properties":{"allowPrivilegeEscalation":{"description":"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"capabilities":{"description":"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.Capabilities"},"privileged":{"description":"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"procMount":{"description":"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"readOnlyRootFilesystem":{"description":"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Capabilities":{"description":"Adds and removes POSIX capabilities from running containers.","properties":{"add":{"description":"Added capabilities","type":"array","items":{"type":"string"}},"drop":{"description":"Removed capabilities","type":"array","items":{"type":"string"}}}},"v1.VolumeDevice":{"description":"volumeDevice describes a mapping of a raw block device within a container.","required":["name","devicePath"],"properties":{"devicePath":{"description":"devicePath is the path inside of the container that the device will be mapped to.","type":"string"},"name":{"description":"name must match the name of a persistentVolumeClaim in the pod","type":"string"}}},"v1.VolumeMount":{"description":"VolumeMount describes a mounting of a Volume within a container.","required":["name","mountPath"],"properties":{"mountPath":{"description":"Path within the container at which the volume should be mounted. Must not contain ':'.","type":"string"},"mountPropagation":{"description":"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10.","type":"string"},"name":{"description":"This must match the Name of a Volume.","type":"string"},"readOnly":{"description":"Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.","type":"boolean"},"subPath":{"description":"Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).","type":"string"},"subPathExpr":{"description":"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.","type":"string"}}},"v1alpha1.ContainerSetTemplate":{"required":["containers"],"properties":{"containers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ContainerNode"}},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.ContainerSetRetryStrategy"},"volumeMounts":{"type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}}}},"v1alpha1.ContainerNode":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"dependencies":{"type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.ContainerSetRetryStrategy":{"required":["retries"],"properties":{"duration":{"type":"string"},"retries":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"v1alpha1.DAGTemplate":{"required":["tasks"],"properties":{"failFast":{"type":"boolean"},"target":{"type":"string"},"tasks":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.DAGTask"}}}},"v1alpha1.DAGTask":{"required":["name"],"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"continueOn":{"$ref":"#/components/schemas/v1alpha1.ContinueOn"},"dependencies":{"type":"array","items":{"type":"string"}},"depends":{"type":"string"},"hooks":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LifecycleHook"}},"inline":{"$ref":"#/components/schemas/v1alpha1.Template"},"name":{"type":"string"},"onExit":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"},"when":{"type":"string"},"withItems":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Item"}},"withParam":{"type":"string"},"withSequence":{"$ref":"#/components/schemas/v1alpha1.Sequence"}}},"v1alpha1.ContinueOn":{"properties":{"error":{"type":"boolean"},"failed":{"type":"boolean"}}},"v1alpha1.Item":{},"v1alpha1.Sequence":{"properties":{"count":{"$ref":"#/components/schemas/intstr.IntOrString"},"end":{"$ref":"#/components/schemas/intstr.IntOrString"},"format":{"type":"string"},"start":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"v1alpha1.Data":{"required":["source","transformation"],"properties":{"source":{"$ref":"#/components/schemas/v1alpha1.DataSource"},"transformation":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.TransformationStep"}}}},"v1alpha1.DataSource":{"properties":{"artifactPaths":{"$ref":"#/components/schemas/v1alpha1.ArtifactPaths"}}},"v1alpha1.ArtifactPaths":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.TransformationStep":{"required":["expression"],"properties":{"expression":{"type":"string"}}},"v1alpha1.HTTP":{"required":["url"],"properties":{"body":{"type":"string"},"bodyFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPBodySource"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.HTTPHeader"}},"insecureSkipVerify":{"type":"boolean"},"method":{"type":"string"},"successCondition":{"type":"string"},"timeoutSeconds":{"type":"integer","format":"int64"},"url":{"type":"string"}}},"v1alpha1.HTTPBodySource":{"properties":{"bytes":{"type":"string"}}},"v1alpha1.HTTPHeader":{"required":["name"],"properties":{"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPHeaderSource"}}},"v1alpha1.HTTPHeaderSource":{"properties":{"secretKeyRef":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.UserContainer":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"mirrorVolumeMounts":{"type":"boolean"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.Inputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Memoize":{"required":["key","cache","maxAge"],"properties":{"cache":{"$ref":"#/components/schemas/v1alpha1.Cache"},"key":{"type":"string"},"maxAge":{"type":"string"}}},"v1alpha1.Cache":{"required":["configMap"],"properties":{"configMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"}}},"v1alpha1.Outputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"exitCode":{"type":"string"},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}},"result":{"type":"string"}}},"v1alpha1.Plugin":{},"v1alpha1.ResourceTemplate":{"required":["action"],"properties":{"action":{"type":"string"},"failureCondition":{"type":"string"},"flags":{"type":"array","items":{"type":"string"}},"manifest":{"type":"string"},"manifestFrom":{"$ref":"#/components/schemas/v1alpha1.ManifestFrom"},"mergeStrategy":{"type":"string"},"setOwnerReference":{"type":"boolean"},"successCondition":{"type":"string"}}},"v1alpha1.ManifestFrom":{"required":["artifact"],"properties":{"artifact":{"$ref":"#/components/schemas/v1alpha1.Artifact"}}},"v1alpha1.ScriptTemplate":{"description":"A single application container that you want to run within a pod.","required":["name","source"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"source":{"type":"string"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.ParallelSteps":{},"v1alpha1.SuspendTemplate":{"properties":{"duration":{"type":"string"}}},"v1.Toleration":{"description":"The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .","properties":{"effect":{"description":"Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.","type":"string"},"key":{"description":"Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.","type":"string"},"operator":{"description":"Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.","type":"string"},"tolerationSeconds":{"description":"TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.","type":"integer","format":"int64"},"value":{"description":"Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.","type":"string"}}},"v1.Volume":{"description":"Volume represents a named volume in a pod that may be accessed by any container in the pod.","required":["name"],"properties":{"awsElasticBlockStore":{"description":"awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","$ref":"#/components/schemas/v1.AWSElasticBlockStoreVolumeSource"},"azureDisk":{"description":"azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureDiskVolumeSource"},"azureFile":{"description":"azureFile represents an Azure File Service mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureFileVolumeSource"},"cephfs":{"description":"cephFS represents a Ceph FS mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.CephFSVolumeSource"},"cinder":{"description":"cinder represents a cinder volume attached and mounted on kubelets host machine. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","$ref":"#/components/schemas/v1.CinderVolumeSource"},"configMap":{"description":"configMap represents a configMap that should populate this volume","$ref":"#/components/schemas/v1.ConfigMapVolumeSource"},"csi":{"description":"csi (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers (Beta feature).","$ref":"#/components/schemas/v1.CSIVolumeSource"},"downwardAPI":{"description":"downwardAPI represents downward API about the pod that should populate this volume","$ref":"#/components/schemas/v1.DownwardAPIVolumeSource"},"emptyDir":{"description":"emptyDir represents a temporary directory that shares a pod's lifetime. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","$ref":"#/components/schemas/v1.EmptyDirVolumeSource"},"ephemeral":{"description":"ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed.\n\nUse this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity\n tracking are needed,\nc) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through\n a PersistentVolumeClaim (see EphemeralVolumeSource for more\n information on the connection between this volume type\n and PersistentVolumeClaim).\n\nUse PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod.\n\nUse CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information.\n\nA pod can use both types of ephemeral volumes and persistent volumes at the same time.","$ref":"#/components/schemas/v1.EphemeralVolumeSource"},"fc":{"description":"fc represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.","$ref":"#/components/schemas/v1.FCVolumeSource"},"flexVolume":{"description":"flexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","$ref":"#/components/schemas/v1.FlexVolumeSource"},"flocker":{"description":"flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running","$ref":"#/components/schemas/v1.FlockerVolumeSource"},"gcePersistentDisk":{"description":"gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","$ref":"#/components/schemas/v1.GCEPersistentDiskVolumeSource"},"gitRepo":{"description":"gitRepo represents a git repository at a particular revision. DEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","$ref":"#/components/schemas/v1.GitRepoVolumeSource"},"glusterfs":{"description":"glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/glusterfs/README.md","$ref":"#/components/schemas/v1.GlusterfsVolumeSource"},"hostPath":{"description":"hostPath represents a pre-existing file or directory on the host machine that is directly exposed to the container. This is generally used for system agents or other privileged things that are allowed to see the host machine. Most containers will NOT need this. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","$ref":"#/components/schemas/v1.HostPathVolumeSource"},"iscsi":{"description":"iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://examples.k8s.io/volumes/iscsi/README.md","$ref":"#/components/schemas/v1.ISCSIVolumeSource"},"name":{"description":"name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"nfs":{"description":"nfs represents an NFS mount on the host that shares a pod's lifetime More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","$ref":"#/components/schemas/v1.NFSVolumeSource"},"persistentVolumeClaim":{"description":"persistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimVolumeSource"},"photonPersistentDisk":{"description":"photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PhotonPersistentDiskVolumeSource"},"portworxVolume":{"description":"portworxVolume represents a portworx volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PortworxVolumeSource"},"projected":{"description":"projected items for all in one resources secrets, configmaps, and downward API","$ref":"#/components/schemas/v1.ProjectedVolumeSource"},"quobyte":{"description":"quobyte represents a Quobyte mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.QuobyteVolumeSource"},"rbd":{"description":"rbd represents a Rados Block Device mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/rbd/README.md","$ref":"#/components/schemas/v1.RBDVolumeSource"},"scaleIO":{"description":"scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.ScaleIOVolumeSource"},"secret":{"description":"secret represents a secret that should populate this volume. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","$ref":"#/components/schemas/v1.SecretVolumeSource"},"storageos":{"description":"storageOS represents a StorageOS volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.StorageOSVolumeSource"},"vsphereVolume":{"description":"vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.VsphereVirtualDiskVolumeSource"}}},"v1.AWSElasticBlockStoreVolumeSource":{"description":"Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).","type":"integer","format":"int32"},"readOnly":{"description":"readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"boolean"},"volumeID":{"description":"volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"}}},"v1.AzureDiskVolumeSource":{"description":"AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","required":["diskName","diskURI"],"properties":{"cachingMode":{"description":"cachingMode is the Host Caching mode: None, Read Only, Read Write.","type":"string"},"diskName":{"description":"diskName is the Name of the data disk in the blob storage","type":"string"},"diskURI":{"description":"diskURI is the URI of data disk in the blob storage","type":"string"},"fsType":{"description":"fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"kind":{"description":"kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"}}},"v1.AzureFileVolumeSource":{"description":"AzureFile represents an Azure File Service mount on the host and bind mount to the pod.","required":["secretName","shareName"],"properties":{"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretName":{"description":"secretName is the name of secret that contains Azure Storage Account Name and Key","type":"string"},"shareName":{"description":"shareName is the azure share Name","type":"string"}}},"v1.CephFSVolumeSource":{"description":"Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.","required":["monitors"],"properties":{"monitors":{"description":"monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"path":{"description":"path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /","type":"string"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"boolean"},"secretFile":{"description":"secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"},"secretRef":{"description":"secretRef is Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"}}},"v1.CinderVolumeSource":{"description":"Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"boolean"},"secretRef":{"description":"secretRef is optional: points to a secret object containing parameters used to connect to OpenStack.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeID":{"description":"volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"}}},"v1.ConfigMapVolumeSource":{"description":"Adapts a ConfigMap into a volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.KeyToPath":{"description":"Maps a string key to a path within a volume.","required":["key","path"],"properties":{"key":{"description":"key is the key to project.","type":"string"},"mode":{"description":"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.","type":"string"}}},"v1.CSIVolumeSource":{"description":"Represents a source location of a volume to mount, managed by an external CSI driver","required":["driver"],"properties":{"driver":{"description":"driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.","type":"string"},"fsType":{"description":"fsType to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.","type":"string"},"nodePublishSecretRef":{"description":"nodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secret references are passed.","$ref":"#/components/schemas/v1.LocalObjectReference"},"readOnly":{"description":"readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).","type":"boolean"},"volumeAttributes":{"description":"volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.","type":"object","additionalProperties":{"type":"string"}}}},"v1.DownwardAPIVolumeSource":{"description":"DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"Items is a list of downward API volume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.DownwardAPIVolumeFile":{"description":"DownwardAPIVolumeFile represents information to create the file containing the pod field","required":["path"],"properties":{"fieldRef":{"description":"Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"mode":{"description":"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'","type":"string"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"}}},"v1.EmptyDirVolumeSource":{"description":"Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.","properties":{"medium":{"description":"medium represents what type of storage medium should back this directory. The default is \"\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","type":"string"},"sizeLimit":{"description":"sizeLimit is the total amount of local storage required for this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. The default is nil which means that the limit is undefined. More info: http://kubernetes.io/docs/user-guide/volumes#emptydir","$ref":"#/components/schemas/resource.Quantity"}}},"v1.EphemeralVolumeSource":{"description":"Represents an ephemeral volume that is handled by a normal storage driver.","properties":{"volumeClaimTemplate":{"description":"Will be used to create a stand-alone PVC to provision the volume. The pod in which this EphemeralVolumeSource is embedded will be the owner of the PVC, i.e. the PVC will be deleted together with the pod. The name of the PVC will be `-` where `` is the name from the `PodSpec.Volumes` array entry. Pod validation will reject the pod if the concatenated name is not valid for a PVC (for example, too long).\n\nAn existing PVC with that name that is not owned by the pod will *not* be used for the pod to avoid using an unrelated volume by mistake. Starting the pod is then blocked until the unrelated PVC is removed. If such a pre-created PVC is meant to be used by the pod, the PVC has to updated with an owner reference to the pod once the pod exists. Normally this should not be necessary, but it may be useful when manually reconstructing a broken cluster.\n\nThis field is read-only and no changes will be made by Kubernetes to the PVC after it has been created.\n\nRequired, must not be nil.","$ref":"#/components/schemas/v1.PersistentVolumeClaimTemplate"}}},"v1.PersistentVolumeClaimTemplate":{"description":"PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.","required":["spec"],"properties":{"metadata":{"description":"May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"The specification for the PersistentVolumeClaim. The entire content is copied unchanged into the PVC that gets created from this template. The same fields as in a PersistentVolumeClaim are also valid here.","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"}}},"v1.PersistentVolumeClaimSpec":{"description":"PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes","properties":{"accessModes":{"description":"accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"dataSource":{"description":"dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"dataSourceRef":{"description":"dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"resources":{"description":"resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources","$ref":"#/components/schemas/v1.ResourceRequirements"},"selector":{"description":"selector is a label query over volumes to consider for binding.","$ref":"#/components/schemas/v1.LabelSelector"},"storageClassName":{"description":"storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1","type":"string"},"volumeMode":{"description":"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.","type":"string"},"volumeName":{"description":"volumeName is the binding reference to the PersistentVolume backing this claim.","type":"string"}}},"v1.TypedLocalObjectReference":{"description":"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.","required":["apiGroup","kind","name"],"properties":{"apiGroup":{"description":"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.","type":"string"},"kind":{"description":"Kind is the type of resource being referenced","type":"string"},"name":{"description":"Name is the name of resource being referenced","type":"string"}}},"v1.FCVolumeSource":{"description":"Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"lun":{"description":"lun is Optional: FC target lun number","type":"integer","format":"int32"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"targetWWNs":{"description":"targetWWNs is Optional: FC target worldwide names (WWNs)","type":"array","items":{"type":"string"}},"wwids":{"description":"wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.","type":"array","items":{"type":"string"}}}},"v1.FlexVolumeSource":{"description":"FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","required":["driver"],"properties":{"driver":{"description":"driver is the name of the driver to use for this volume.","type":"string"},"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.","type":"string"},"options":{"description":"options is Optional: this field holds extra command options if any.","type":"object","additionalProperties":{"type":"string"}},"readOnly":{"description":"readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef is Optional: secretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts.","$ref":"#/components/schemas/v1.LocalObjectReference"}}},"v1.FlockerVolumeSource":{"description":"Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.","properties":{"datasetName":{"description":"datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated","type":"string"},"datasetUUID":{"description":"datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset","type":"string"}}},"v1.GCEPersistentDiskVolumeSource":{"description":"Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.","required":["pdName"],"properties":{"fsType":{"description":"fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"integer","format":"int32"},"pdName":{"description":"pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"boolean"}}},"v1.GitRepoVolumeSource":{"description":"Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","required":["repository"],"properties":{"directory":{"description":"directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.","type":"string"},"repository":{"description":"repository is the URL","type":"string"},"revision":{"description":"revision is the commit hash for the specified revision.","type":"string"}}},"v1.GlusterfsVolumeSource":{"description":"Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.","required":["endpoints","path"],"properties":{"endpoints":{"description":"endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"path":{"description":"path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"readOnly":{"description":"readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"boolean"}}},"v1.HostPathVolumeSource":{"description":"Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.","required":["path"],"properties":{"path":{"description":"path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"},"type":{"description":"type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"}}},"v1.ISCSIVolumeSource":{"description":"Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.","required":["targetPortal","iqn","lun"],"properties":{"chapAuthDiscovery":{"description":"chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication","type":"boolean"},"chapAuthSession":{"description":"chapAuthSession defines whether support iSCSI Session CHAP authentication","type":"boolean"},"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi","type":"string"},"initiatorName":{"description":"initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.","type":"string"},"iqn":{"description":"iqn is the target iSCSI Qualified Name.","type":"string"},"iscsiInterface":{"description":"iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).","type":"string"},"lun":{"description":"lun represents iSCSI Target Lun number.","type":"integer","format":"int32"},"portals":{"description":"portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"array","items":{"type":"string"}},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.","type":"boolean"},"secretRef":{"description":"secretRef is the CHAP Secret for iSCSI target and initiator authentication","$ref":"#/components/schemas/v1.LocalObjectReference"},"targetPortal":{"description":"targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"string"}}},"v1.NFSVolumeSource":{"description":"Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.","required":["server","path"],"properties":{"path":{"description":"path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"},"readOnly":{"description":"readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"boolean"},"server":{"description":"server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"}}},"v1.PersistentVolumeClaimVolumeSource":{"description":"PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).","required":["claimName"],"properties":{"claimName":{"description":"claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","type":"string"},"readOnly":{"description":"readOnly Will force the ReadOnly setting in VolumeMounts. Default false.","type":"boolean"}}},"v1.PhotonPersistentDiskVolumeSource":{"description":"Represents a Photon Controller persistent disk resource.","required":["pdID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"pdID":{"description":"pdID is the ID that identifies Photon Controller persistent disk","type":"string"}}},"v1.PortworxVolumeSource":{"description":"PortworxVolumeSource represents a Portworx volume resource.","required":["volumeID"],"properties":{"fsType":{"description":"fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"volumeID":{"description":"volumeID uniquely identifies a Portworx volume","type":"string"}}},"v1.ProjectedVolumeSource":{"description":"Represents a projected volume source","required":["sources"],"properties":{"defaultMode":{"description":"defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"sources":{"description":"sources is the list of volume projections","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeProjection"}}}},"v1.VolumeProjection":{"description":"Projection that may be projected along with other supported volume types","properties":{"configMap":{"description":"configMap information about the configMap data to project","$ref":"#/components/schemas/v1.ConfigMapProjection"},"downwardAPI":{"description":"downwardAPI information about the downwardAPI data to project","$ref":"#/components/schemas/v1.DownwardAPIProjection"},"secret":{"description":"secret information about the secret data to project","$ref":"#/components/schemas/v1.SecretProjection"},"serviceAccountToken":{"description":"serviceAccountToken is information about the serviceAccountToken data to project","$ref":"#/components/schemas/v1.ServiceAccountTokenProjection"}}},"v1.ConfigMapProjection":{"description":"Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.DownwardAPIProjection":{"description":"Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.","properties":{"items":{"description":"Items is a list of DownwardAPIVolume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.SecretProjection":{"description":"Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional field specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.ServiceAccountTokenProjection":{"description":"ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).","required":["path"],"properties":{"audience":{"description":"audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.","type":"string"},"expirationSeconds":{"description":"expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.","type":"integer","format":"int64"},"path":{"description":"path is the path relative to the mount point of the file to project the token into.","type":"string"}}},"v1.QuobyteVolumeSource":{"description":"Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.","required":["registry","volume"],"properties":{"group":{"description":"group to map volume access to Default is no group","type":"string"},"readOnly":{"description":"readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.","type":"boolean"},"registry":{"description":"registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes","type":"string"},"tenant":{"description":"tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin","type":"string"},"user":{"description":"user to map volume access to Defaults to serivceaccount user","type":"string"},"volume":{"description":"volume is a string that references an already created Quobyte volume by name.","type":"string"}}},"v1.RBDVolumeSource":{"description":"Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.","required":["monitors","image"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd","type":"string"},"image":{"description":"image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"keyring":{"description":"keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"monitors":{"description":"monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"pool":{"description":"pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"boolean"},"secretRef":{"description":"secretRef is name of the authentication secret for RBDUser. If provided overrides keyring. Default is nil. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"}}},"v1.ScaleIOVolumeSource":{"description":"ScaleIOVolumeSource represents a persistent ScaleIO volume","required":["gateway","system","secretRef"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\".","type":"string"},"gateway":{"description":"gateway is the host address of the ScaleIO API Gateway.","type":"string"},"protectionDomain":{"description":"protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef references to the secret for ScaleIO user and other sensitive information. If this is not provided, Login operation will fail.","$ref":"#/components/schemas/v1.LocalObjectReference"},"sslEnabled":{"description":"sslEnabled Flag enable/disable SSL communication with Gateway, default false","type":"boolean"},"storageMode":{"description":"storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.","type":"string"},"storagePool":{"description":"storagePool is the ScaleIO Storage Pool associated with the protection domain.","type":"string"},"system":{"description":"system is the name of the storage system as configured in ScaleIO.","type":"string"},"volumeName":{"description":"volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.","type":"string"}}},"v1.SecretVolumeSource":{"description":"Adapts a Secret into a volume.\n\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"optional":{"description":"optional field specify whether the Secret or its keys must be defined","type":"boolean"},"secretName":{"description":"secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","type":"string"}}},"v1.StorageOSVolumeSource":{"description":"Represents a StorageOS persistent volume resource.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeName":{"description":"volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.","type":"string"},"volumeNamespace":{"description":"volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.","type":"string"}}},"v1.VsphereVirtualDiskVolumeSource":{"description":"Represents a vSphere volume resource.","required":["volumePath"],"properties":{"fsType":{"description":"fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"storagePolicyID":{"description":"storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.","type":"string"},"storagePolicyName":{"description":"storagePolicyName is the storage Policy Based Management (SPBM) profile name.","type":"string"},"volumePath":{"description":"volumePath is the path that identifies vSphere volume vmdk","type":"string"}}},"v1alpha1.TTLStrategy":{"properties":{"secondsAfterCompletion":{"type":"integer","format":"int32"},"secondsAfterFailure":{"type":"integer","format":"int32"},"secondsAfterSuccess":{"type":"integer","format":"int32"}}},"v1alpha1.VolumeClaimGC":{"properties":{"strategy":{"type":"string"}}},"v1.PersistentVolumeClaim":{"description":"PersistentVolumeClaim is a user's request for and claim to a persistent volume","properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"description":"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"spec defines the desired characteristics of a volume requested by a pod author. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"},"status":{"description":"status represents the current information/status of a persistent volume claim. Read-only. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimStatus"}}},"v1.PersistentVolumeClaimStatus":{"description":"PersistentVolumeClaimStatus is the current status of a persistent volume claim.","properties":{"accessModes":{"description":"accessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"allocatedResources":{"description":"allocatedResources is the storage resource within AllocatedResources tracks the capacity allocated to a PVC. It may be larger than the actual capacity when a volume expansion operation is requested. For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. If a volume expansion capacity request is lowered, allocatedResources is only lowered if there are no expansion operations in progress and if the actual volume capacity is equal or lower than the requested capacity. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"capacity":{"description":"capacity represents the actual resources of the underlying volume.","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"conditions":{"description":"conditions is the current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'ResizeStarted'.","type":"array","items":{"$ref":"#/components/schemas/v1.PersistentVolumeClaimCondition"}},"phase":{"description":"phase represents the current phase of PersistentVolumeClaim.","type":"string"},"resizeStatus":{"description":"resizeStatus stores status of resize operation. ResizeStatus is not set by default but when expansion is complete resizeStatus is set to empty string by resize controller or kubelet. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.","type":"string"}}},"v1.PersistentVolumeClaimCondition":{"description":"PersistentVolumeClaimCondition contails details about state of pvc","required":["type","status"],"properties":{"lastProbeTime":{"description":"lastProbeTime is the time we probed the condition.","$ref":"#/components/schemas/v1.Time"},"lastTransitionTime":{"description":"lastTransitionTime is the time the condition transitioned from one status to another.","$ref":"#/components/schemas/v1.Time"},"message":{"description":"message is the human-readable message indicating details about last transition.","type":"string"},"reason":{"description":"reason is a unique, this should be a short, machine understandable string that gives the reason for condition's last transition. If it reports \"ResizeStarted\" that means the underlying persistent volume is being resized.","type":"string"},"status":{"type":"string"},"type":{"type":"string"}}},"v1alpha1.WorkflowMetadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}},"labelsFrom":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LabelValueFrom"}}}},"v1alpha1.LabelValueFrom":{"required":["expression"],"properties":{"expression":{"type":"string"}}},"v1alpha1.WorkflowTemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"}}},"v1alpha1.WorkflowStatus":{"properties":{"artifactGCStatus":{"$ref":"#/components/schemas/v1alpha1.ArtGCStatus"},"artifactRepositoryRef":{"$ref":"#/components/schemas/v1alpha1.ArtifactRepositoryRefStatus"},"compressedNodes":{"type":"string"},"conditions":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Condition"}},"estimatedDuration":{"type":"integer","format":"int32"},"finishedAt":{"$ref":"#/components/schemas/v1.Time"},"message":{"type":"string"},"nodes":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.NodeStatus"}},"offloadNodeStatusVersion":{"type":"string"},"outputs":{"$ref":"#/components/schemas/v1alpha1.Outputs"},"persistentVolumeClaims":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}},"phase":{"type":"string"},"progress":{"type":"string"},"resourcesDuration":{"type":"object","additionalProperties":{"type":"integer"}},"startedAt":{"$ref":"#/components/schemas/v1.Time"},"storedTemplates":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.Template"}},"storedWorkflowTemplateSpec":{"$ref":"#/components/schemas/v1alpha1.WorkflowSpec"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.SynchronizationStatus"},"taskResultsCompletionStatus":{"type":"object","additionalProperties":{"type":"boolean"}}}},"v1alpha1.ArtGCStatus":{"properties":{"notSpecified":{"type":"boolean"},"podsRecouped":{"type":"object","additionalProperties":{"type":"boolean"}},"strategiesProcessed":{"type":"object","additionalProperties":{"type":"boolean"}}}},"v1alpha1.ArtifactRepositoryRefStatus":{"properties":{"artifactRepository":{"$ref":"#/components/schemas/v1alpha1.ArtifactRepository"},"configMap":{"type":"string"},"default":{"type":"boolean"},"key":{"type":"string"},"namespace":{"type":"string"}}},"v1alpha1.ArtifactRepository":{"properties":{"archiveLogs":{"type":"boolean"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifactRepository"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifactRepository"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifactRepository"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifactRepository"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifactRepository"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3ArtifactRepository"}}},"v1alpha1.ArtifactoryArtifactRepository":{"properties":{"keyFormat":{"type":"string"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repoURL":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.AzureArtifactRepository":{"required":["endpoint","container"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blobNameFormat":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifactRepository":{"properties":{"bucket":{"type":"string"},"keyFormat":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifactRepository":{"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"pathFormat":{"type":"string"}}},"v1alpha1.OSSArtifactRepository":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"keyFormat":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.S3ArtifactRepository":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"keyFormat":{"type":"string"},"keyPrefix":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.Condition":{"properties":{"message":{"type":"string"},"status":{"type":"string"},"type":{"type":"string"}}},"v1alpha1.NodeStatus":{"required":["id","name","type"],"properties":{"boundaryID":{"type":"string"},"children":{"type":"array","items":{"type":"string"}},"daemoned":{"type":"boolean"},"displayName":{"type":"string"},"estimatedDuration":{"type":"integer","format":"int32"},"finishedAt":{"$ref":"#/components/schemas/v1.Time"},"hostNodeName":{"type":"string"},"id":{"type":"string"},"inputs":{"$ref":"#/components/schemas/v1alpha1.Inputs"},"memoizationStatus":{"$ref":"#/components/schemas/v1alpha1.MemoizationStatus"},"message":{"type":"string"},"name":{"type":"string"},"nodeFlag":{"$ref":"#/components/schemas/v1alpha1.NodeFlag"},"outboundNodes":{"type":"array","items":{"type":"string"}},"outputs":{"$ref":"#/components/schemas/v1alpha1.Outputs"},"phase":{"type":"string"},"podIP":{"type":"string"},"progress":{"type":"string"},"resourcesDuration":{"type":"object","additionalProperties":{"type":"integer"}},"startedAt":{"$ref":"#/components/schemas/v1.Time"},"synchronizationStatus":{"$ref":"#/components/schemas/v1alpha1.NodeSynchronizationStatus"},"templateName":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"},"templateScope":{"type":"string"},"type":{"type":"string"}}},"v1alpha1.MemoizationStatus":{"required":["hit","key","cacheName"],"properties":{"cacheName":{"type":"string"},"hit":{"type":"boolean"},"key":{"type":"string"}}},"v1alpha1.NodeFlag":{"properties":{"hooked":{"type":"boolean"},"retried":{"type":"boolean"}}},"v1alpha1.NodeSynchronizationStatus":{"properties":{"waiting":{"type":"string"}}},"v1alpha1.SynchronizationStatus":{"properties":{"mutex":{"$ref":"#/components/schemas/v1alpha1.MutexStatus"},"semaphore":{"$ref":"#/components/schemas/v1alpha1.SemaphoreStatus"}}},"v1alpha1.MutexStatus":{"properties":{"holding":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MutexHolding"}},"waiting":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MutexHolding"}}}},"v1alpha1.MutexHolding":{"properties":{"holder":{"type":"string"},"mutex":{"type":"string"}}},"v1alpha1.SemaphoreStatus":{"properties":{"holding":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.SemaphoreHolding"}},"waiting":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.SemaphoreHolding"}}}},"v1alpha1.SemaphoreHolding":{"properties":{"holders":{"type":"array","items":{"type":"string"}},"semaphore":{"type":"string"}}}}}} ``` ## The v1alpha1.WorkflowLevelArtifactGC object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.WorkflowLevelArtifactGC":{"properties":{"forceFinalizerRemoval":{"type":"boolean"},"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"podSpecPatch":{"type":"string"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}}}}} ``` ## The v1alpha1.WorkflowMetadata object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.WorkflowMetadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}},"labelsFrom":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LabelValueFrom"}}}},"v1alpha1.LabelValueFrom":{"required":["expression"],"properties":{"expression":{"type":"string"}}}}}} ``` ## The v1alpha1.WorkflowSpec object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.WorkflowSpec":{"properties":{"activeDeadlineSeconds":{"type":"integer","format":"int64"},"affinity":{"$ref":"#/components/schemas/v1.Affinity"},"archiveLogs":{"type":"boolean"},"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.WorkflowLevelArtifactGC"},"artifactRepositoryRef":{"$ref":"#/components/schemas/v1alpha1.ArtifactRepositoryRef"},"automountServiceAccountToken":{"type":"boolean"},"dnsConfig":{"$ref":"#/components/schemas/v1.PodDNSConfig"},"dnsPolicy":{"type":"string"},"entrypoint":{"type":"string"},"executor":{"$ref":"#/components/schemas/v1alpha1.ExecutorConfig"},"hooks":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LifecycleHook"}},"hostAliases":{"type":"array","items":{"$ref":"#/components/schemas/v1.HostAlias"}},"hostNetwork":{"type":"boolean"},"imagePullSecrets":{"type":"array","items":{"$ref":"#/components/schemas/v1.LocalObjectReference"}},"metrics":{"$ref":"#/components/schemas/v1alpha1.Metrics"},"nodeSelector":{"type":"object","additionalProperties":{"type":"string"}},"onExit":{"type":"string"},"parallelism":{"type":"integer","format":"int64"},"podDisruptionBudget":{"$ref":"#/components/schemas/v1.PodDisruptionBudgetSpec"},"podGC":{"$ref":"#/components/schemas/v1alpha1.PodGC"},"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"podPriority":{"type":"integer","format":"int32"},"podPriorityClassName":{"type":"string"},"podSpecPatch":{"type":"string"},"priority":{"type":"integer","format":"int32"},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.RetryStrategy"},"schedulerName":{"type":"string"},"securityContext":{"$ref":"#/components/schemas/v1.PodSecurityContext"},"serviceAccountName":{"type":"string"},"shutdown":{"type":"string"},"suspend":{"type":"boolean"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.Synchronization"},"templateDefaults":{"$ref":"#/components/schemas/v1alpha1.Template"},"templates":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Template"}},"tolerations":{"type":"array","items":{"$ref":"#/components/schemas/v1.Toleration"}},"ttlStrategy":{"$ref":"#/components/schemas/v1alpha1.TTLStrategy"},"volumeClaimGC":{"$ref":"#/components/schemas/v1alpha1.VolumeClaimGC"},"volumeClaimTemplates":{"type":"array","items":{"$ref":"#/components/schemas/v1.PersistentVolumeClaim"}},"volumes":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}},"workflowMetadata":{"$ref":"#/components/schemas/v1alpha1.WorkflowMetadata"},"workflowTemplateRef":{"$ref":"#/components/schemas/v1alpha1.WorkflowTemplateRef"}}},"v1.Affinity":{"description":"Affinity is a group of affinity scheduling rules.","properties":{"nodeAffinity":{"description":"Describes node affinity scheduling rules for the pod.","$ref":"#/components/schemas/v1.NodeAffinity"},"podAffinity":{"description":"Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAffinity"},"podAntiAffinity":{"description":"Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAntiAffinity"}}},"v1.NodeAffinity":{"description":"Node affinity is a group of node affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.PreferredSchedulingTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.","$ref":"#/components/schemas/v1.NodeSelector"}}},"v1.PreferredSchedulingTerm":{"description":"An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).","required":["weight","preference"],"properties":{"preference":{"description":"A node selector term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.NodeSelectorTerm"},"weight":{"description":"Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.NodeSelectorTerm":{"description":"A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.","properties":{"matchExpressions":{"description":"A list of node selector requirements by node's labels.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}},"matchFields":{"description":"A list of node selector requirements by node's fields.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}}}},"v1.NodeSelectorRequirement":{"description":"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"The label key that the selector applies to.","type":"string"},"operator":{"description":"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.","type":"string"},"values":{"description":"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.NodeSelector":{"description":"A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.","required":["nodeSelectorTerms"],"properties":{"nodeSelectorTerms":{"description":"Required. A list of node selector terms. The terms are ORed.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorTerm"}}}},"v1.PodAffinity":{"description":"Pod affinity is a group of inter pod affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1.WeightedPodAffinityTerm":{"description":"The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)","required":["weight","podAffinityTerm"],"properties":{"podAffinityTerm":{"description":"Required. A pod affinity term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.PodAffinityTerm"},"weight":{"description":"weight associated with matching the corresponding podAffinityTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.PodAffinityTerm":{"description":"Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running","required":["topologyKey"],"properties":{"labelSelector":{"description":"A label query over a set of resources, in this case pods.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaceSelector":{"description":"A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means \"this pod's namespace\". An empty selector ({}) matches all namespaces.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaces":{"description":"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".","type":"array","items":{"type":"string"}},"topologyKey":{"description":"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.","type":"string"}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.PodAntiAffinity":{"description":"Pod anti affinity is a group of inter pod anti affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1alpha1.Arguments":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Artifact":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.Parameter":{"required":["name"],"properties":{"default":{"type":"string"},"description":{"type":"string"},"enum":{"type":"array","items":{"type":"string"}},"globalName":{"type":"string"},"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.ValueFrom"}}},"v1alpha1.ValueFrom":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"default":{"type":"string"},"event":{"type":"string"},"expression":{"type":"string"},"jqFilter":{"type":"string"},"jsonPath":{"type":"string"},"parameter":{"type":"string"},"path":{"type":"string"},"supplied":{"$ref":"#/components/schemas/v1alpha1.SuppliedValueFrom"}}},"v1alpha1.SuppliedValueFrom":{},"v1alpha1.WorkflowLevelArtifactGC":{"properties":{"forceFinalizerRemoval":{"type":"boolean"},"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"podSpecPatch":{"type":"string"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.ArtifactRepositoryRef":{"properties":{"configMap":{"type":"string"},"key":{"type":"string"}}},"v1.PodDNSConfig":{"description":"PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy.","properties":{"nameservers":{"description":"A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed.","type":"array","items":{"type":"string"}},"options":{"description":"A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy.","type":"array","items":{"$ref":"#/components/schemas/v1.PodDNSConfigOption"}},"searches":{"description":"A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed.","type":"array","items":{"type":"string"}}}},"v1.PodDNSConfigOption":{"description":"PodDNSConfigOption defines DNS resolver options of a pod.","properties":{"name":{"description":"Required.","type":"string"},"value":{"type":"string"}}},"v1alpha1.ExecutorConfig":{"properties":{"serviceAccountName":{"type":"string"}}},"v1alpha1.LifecycleHook":{"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"expression":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"}}},"v1alpha1.TemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"},"template":{"type":"string"}}},"v1.HostAlias":{"description":"HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.","properties":{"hostnames":{"description":"Hostnames for the above IP address.","type":"array","items":{"type":"string"}},"ip":{"description":"IP address of the host file entry.","type":"string"}}},"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}},"v1alpha1.Metrics":{"required":["prometheus"],"properties":{"prometheus":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Prometheus"}}}},"v1alpha1.Prometheus":{"required":["name","help"],"properties":{"counter":{"$ref":"#/components/schemas/v1alpha1.Counter"},"gauge":{"$ref":"#/components/schemas/v1alpha1.Gauge"},"help":{"type":"string"},"histogram":{"$ref":"#/components/schemas/v1alpha1.Histogram"},"labels":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MetricLabel"}},"name":{"type":"string"},"when":{"type":"string"}}},"v1alpha1.Counter":{"required":["value"],"properties":{"value":{"type":"string"}}},"v1alpha1.Gauge":{"required":["value","realtime"],"properties":{"operation":{"type":"string"},"realtime":{"type":"boolean"},"value":{"type":"string"}}},"v1alpha1.Histogram":{"required":["value","buckets"],"properties":{"buckets":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Amount"}},"value":{"type":"string"}}},"v1alpha1.Amount":{},"v1alpha1.MetricLabel":{"required":["key","value"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1.PodDisruptionBudgetSpec":{"description":"PodDisruptionBudgetSpec is a description of a PodDisruptionBudget.","properties":{"maxUnavailable":{"description":"An eviction is allowed if at most \"maxUnavailable\" pods selected by \"selector\" are unavailable after the eviction, i.e. even in absence of the evicted pod. For example, one can prevent all voluntary evictions by specifying 0. This is a mutually exclusive setting with \"minAvailable\".","$ref":"#/components/schemas/intstr.IntOrString"},"minAvailable":{"description":"An eviction is allowed if at least \"minAvailable\" pods selected by \"selector\" will still be available after the eviction, i.e. even in the absence of the evicted pod. So for example you can prevent all voluntary evictions by specifying \"100%\".","$ref":"#/components/schemas/intstr.IntOrString"},"selector":{"description":"Label query over pods whose evictions are managed by the disruption budget. A null selector will match no pods, while an empty ({}) selector will select all pods within the namespace.","$ref":"#/components/schemas/v1.LabelSelector"}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}},"v1alpha1.PodGC":{"properties":{"deleteDelayDuration":{"type":"string"},"labelSelector":{"$ref":"#/components/schemas/v1.LabelSelector"},"strategy":{"type":"string"}}},"v1alpha1.RetryStrategy":{"properties":{"affinity":{"$ref":"#/components/schemas/v1alpha1.RetryAffinity"},"backoff":{"$ref":"#/components/schemas/v1alpha1.Backoff"},"expression":{"type":"string"},"limit":{"$ref":"#/components/schemas/intstr.IntOrString"},"retryPolicy":{"type":"string"}}},"v1alpha1.RetryAffinity":{"properties":{"nodeAntiAffinity":{"$ref":"#/components/schemas/v1alpha1.RetryNodeAntiAffinity"}}},"v1alpha1.RetryNodeAntiAffinity":{},"v1alpha1.Backoff":{"properties":{"duration":{"type":"string"},"factor":{"$ref":"#/components/schemas/intstr.IntOrString"},"maxDuration":{"type":"string"}}},"v1.PodSecurityContext":{"description":"PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.","properties":{"fsGroup":{"description":"A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\n\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw ","type":"integer","format":"int64"},"fsGroupChangePolicy":{"description":"fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \"OnRootMismatch\" and \"Always\". If not specified, \"Always\" is used. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"supplementalGroups":{"description":"A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"type":"integer","format":"int64"}},"sysctls":{"description":"Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"$ref":"#/components/schemas/v1.Sysctl"}},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.SELinuxOptions":{"description":"SELinuxOptions are the labels to be applied to the container","properties":{"level":{"description":"Level is SELinux level label that applies to the container.","type":"string"},"role":{"description":"Role is a SELinux role label that applies to the container.","type":"string"},"type":{"description":"Type is a SELinux type label that applies to the container.","type":"string"},"user":{"description":"User is a SELinux user label that applies to the container.","type":"string"}}},"v1.SeccompProfile":{"description":"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.","required":["type"],"properties":{"localhostProfile":{"description":"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is \"Localhost\".","type":"string"},"type":{"description":"type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.","type":"string"}}},"v1.Sysctl":{"description":"Sysctl defines a kernel parameter to be set","required":["name","value"],"properties":{"name":{"description":"Name of a property to set","type":"string"},"value":{"description":"Value of a property to set","type":"string"}}},"v1.WindowsSecurityContextOptions":{"description":"WindowsSecurityContextOptions contain Windows-specific options and credentials.","properties":{"gmsaCredentialSpec":{"description":"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.","type":"string"},"gmsaCredentialSpecName":{"description":"GMSACredentialSpecName is the name of the GMSA credential spec to use.","type":"string"},"hostProcess":{"description":"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.","type":"boolean"},"runAsUserName":{"description":"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"string"}}},"v1alpha1.Synchronization":{"properties":{"mutex":{"$ref":"#/components/schemas/v1alpha1.Mutex"},"semaphore":{"$ref":"#/components/schemas/v1alpha1.SemaphoreRef"}}},"v1alpha1.Mutex":{"properties":{"name":{"type":"string"},"namespace":{"type":"string"}}},"v1alpha1.SemaphoreRef":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"namespace":{"type":"string"}}},"v1alpha1.Template":{"properties":{"activeDeadlineSeconds":{"$ref":"#/components/schemas/intstr.IntOrString"},"affinity":{"$ref":"#/components/schemas/v1.Affinity"},"archiveLocation":{"$ref":"#/components/schemas/v1alpha1.ArtifactLocation"},"automountServiceAccountToken":{"type":"boolean"},"container":{"$ref":"#/components/schemas/v1.Container"},"containerSet":{"$ref":"#/components/schemas/v1alpha1.ContainerSetTemplate"},"daemon":{"type":"boolean"},"dag":{"$ref":"#/components/schemas/v1alpha1.DAGTemplate"},"data":{"$ref":"#/components/schemas/v1alpha1.Data"},"executor":{"$ref":"#/components/schemas/v1alpha1.ExecutorConfig"},"failFast":{"type":"boolean"},"hostAliases":{"type":"array","items":{"$ref":"#/components/schemas/v1.HostAlias"}},"http":{"$ref":"#/components/schemas/v1alpha1.HTTP"},"initContainers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"inputs":{"$ref":"#/components/schemas/v1alpha1.Inputs"},"memoize":{"$ref":"#/components/schemas/v1alpha1.Memoize"},"metadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"metrics":{"$ref":"#/components/schemas/v1alpha1.Metrics"},"name":{"type":"string"},"nodeSelector":{"type":"object","additionalProperties":{"type":"string"}},"outputs":{"$ref":"#/components/schemas/v1alpha1.Outputs"},"parallelism":{"type":"integer","format":"int64"},"plugin":{"$ref":"#/components/schemas/v1alpha1.Plugin"},"podSpecPatch":{"type":"string"},"priority":{"type":"integer","format":"int32"},"priorityClassName":{"type":"string"},"resource":{"$ref":"#/components/schemas/v1alpha1.ResourceTemplate"},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.RetryStrategy"},"schedulerName":{"type":"string"},"script":{"$ref":"#/components/schemas/v1alpha1.ScriptTemplate"},"securityContext":{"$ref":"#/components/schemas/v1.PodSecurityContext"},"serviceAccountName":{"type":"string"},"sidecars":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"steps":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ParallelSteps"}},"suspend":{"$ref":"#/components/schemas/v1alpha1.SuspendTemplate"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.Synchronization"},"timeout":{"type":"string"},"tolerations":{"type":"array","items":{"$ref":"#/components/schemas/v1.Toleration"}},"volumes":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}}}},"v1alpha1.ArtifactLocation":{"properties":{"archiveLogs":{"type":"boolean"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"}}},"v1.Container":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1.EnvVar":{"description":"EnvVar represents an environment variable present in a Container.","required":["name"],"properties":{"name":{"description":"Name of the environment variable. Must be a C_IDENTIFIER.","type":"string"},"value":{"description":"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".","type":"string"},"valueFrom":{"description":"Source for the environment variable's value. Cannot be used if value is not empty.","$ref":"#/components/schemas/v1.EnvVarSource"}}},"v1.EnvVarSource":{"description":"EnvVarSource represents a source for the value of an EnvVar.","properties":{"configMapKeyRef":{"description":"Selects a key of a ConfigMap.","$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"fieldRef":{"description":"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"},"secretKeyRef":{"description":"Selects a key of a secret in the pod's namespace","$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.EnvFromSource":{"description":"EnvFromSource represents the source of a set of ConfigMaps","properties":{"configMapRef":{"description":"The ConfigMap to select from","$ref":"#/components/schemas/v1.ConfigMapEnvSource"},"prefix":{"description":"An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.","type":"string"},"secretRef":{"description":"The Secret to select from","$ref":"#/components/schemas/v1.SecretEnvSource"}}},"v1.ConfigMapEnvSource":{"description":"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap must be defined","type":"boolean"}}},"v1.SecretEnvSource":{"description":"SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret must be defined","type":"boolean"}}},"v1.Lifecycle":{"description":"Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.","properties":{"postStart":{"description":"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"},"preStop":{"description":"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"}}},"v1.LifecycleHandler":{"description":"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"tcpSocket":{"description":"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.","$ref":"#/components/schemas/v1.TCPSocketAction"}}},"v1.ExecAction":{"description":"ExecAction describes a \"run in container\" action.","properties":{"command":{"description":"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.","type":"array","items":{"type":"string"}}}},"v1.HTTPGetAction":{"description":"HTTPGetAction describes an action based on HTTP Get requests.","required":["port"],"properties":{"host":{"description":"Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.","type":"string"},"httpHeaders":{"description":"Custom headers to set in the request. HTTP allows repeated headers.","type":"array","items":{"$ref":"#/components/schemas/v1.HTTPHeader"}},"path":{"description":"Path to access on the HTTP server.","type":"string"},"port":{"description":"Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"},"scheme":{"description":"Scheme to use for connecting to the host. Defaults to HTTP.","type":"string"}}},"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}},"v1.TCPSocketAction":{"description":"TCPSocketAction describes an action based on opening a socket","required":["port"],"properties":{"host":{"description":"Optional: Host name to connect to, defaults to the pod IP.","type":"string"},"port":{"description":"Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"}}},"v1.Probe":{"description":"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"failureThreshold":{"description":"Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.","type":"integer","format":"int32"},"grpc":{"description":"GRPC specifies an action involving a GRPC port. This is a beta field and requires enabling GRPCContainerProbe feature gate.","$ref":"#/components/schemas/v1.GRPCAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"initialDelaySeconds":{"description":"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"},"periodSeconds":{"description":"How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.","type":"integer","format":"int32"},"successThreshold":{"description":"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.","type":"integer","format":"int32"},"tcpSocket":{"description":"TCPSocket specifies an action involving a TCP port.","$ref":"#/components/schemas/v1.TCPSocketAction"},"terminationGracePeriodSeconds":{"description":"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.","type":"integer","format":"int64"},"timeoutSeconds":{"description":"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"}}},"v1.GRPCAction":{"required":["port","service"],"properties":{"port":{"description":"Port number of the gRPC service. Number must be in the range 1 to 65535.","type":"integer","format":"int32"},"service":{"description":"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.","type":"string"}}},"v1.ContainerPort":{"description":"ContainerPort represents a network port in a single container.","required":["containerPort"],"properties":{"containerPort":{"description":"Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.","type":"integer","format":"int32"},"hostIP":{"description":"What host IP to bind the external port to.","type":"string"},"hostPort":{"description":"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.","type":"integer","format":"int32"},"name":{"description":"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.","type":"string"},"protocol":{"description":"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"v1.SecurityContext":{"description":"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.","properties":{"allowPrivilegeEscalation":{"description":"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"capabilities":{"description":"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.Capabilities"},"privileged":{"description":"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"procMount":{"description":"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"readOnlyRootFilesystem":{"description":"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Capabilities":{"description":"Adds and removes POSIX capabilities from running containers.","properties":{"add":{"description":"Added capabilities","type":"array","items":{"type":"string"}},"drop":{"description":"Removed capabilities","type":"array","items":{"type":"string"}}}},"v1.VolumeDevice":{"description":"volumeDevice describes a mapping of a raw block device within a container.","required":["name","devicePath"],"properties":{"devicePath":{"description":"devicePath is the path inside of the container that the device will be mapped to.","type":"string"},"name":{"description":"name must match the name of a persistentVolumeClaim in the pod","type":"string"}}},"v1.VolumeMount":{"description":"VolumeMount describes a mounting of a Volume within a container.","required":["name","mountPath"],"properties":{"mountPath":{"description":"Path within the container at which the volume should be mounted. Must not contain ':'.","type":"string"},"mountPropagation":{"description":"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10.","type":"string"},"name":{"description":"This must match the Name of a Volume.","type":"string"},"readOnly":{"description":"Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.","type":"boolean"},"subPath":{"description":"Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).","type":"string"},"subPathExpr":{"description":"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.","type":"string"}}},"v1alpha1.ContainerSetTemplate":{"required":["containers"],"properties":{"containers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ContainerNode"}},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.ContainerSetRetryStrategy"},"volumeMounts":{"type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}}}},"v1alpha1.ContainerNode":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"dependencies":{"type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.ContainerSetRetryStrategy":{"required":["retries"],"properties":{"duration":{"type":"string"},"retries":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"v1alpha1.DAGTemplate":{"required":["tasks"],"properties":{"failFast":{"type":"boolean"},"target":{"type":"string"},"tasks":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.DAGTask"}}}},"v1alpha1.DAGTask":{"required":["name"],"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"continueOn":{"$ref":"#/components/schemas/v1alpha1.ContinueOn"},"dependencies":{"type":"array","items":{"type":"string"}},"depends":{"type":"string"},"hooks":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LifecycleHook"}},"inline":{"$ref":"#/components/schemas/v1alpha1.Template"},"name":{"type":"string"},"onExit":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"},"when":{"type":"string"},"withItems":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Item"}},"withParam":{"type":"string"},"withSequence":{"$ref":"#/components/schemas/v1alpha1.Sequence"}}},"v1alpha1.ContinueOn":{"properties":{"error":{"type":"boolean"},"failed":{"type":"boolean"}}},"v1alpha1.Item":{},"v1alpha1.Sequence":{"properties":{"count":{"$ref":"#/components/schemas/intstr.IntOrString"},"end":{"$ref":"#/components/schemas/intstr.IntOrString"},"format":{"type":"string"},"start":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"v1alpha1.Data":{"required":["source","transformation"],"properties":{"source":{"$ref":"#/components/schemas/v1alpha1.DataSource"},"transformation":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.TransformationStep"}}}},"v1alpha1.DataSource":{"properties":{"artifactPaths":{"$ref":"#/components/schemas/v1alpha1.ArtifactPaths"}}},"v1alpha1.ArtifactPaths":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.TransformationStep":{"required":["expression"],"properties":{"expression":{"type":"string"}}},"v1alpha1.HTTP":{"required":["url"],"properties":{"body":{"type":"string"},"bodyFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPBodySource"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.HTTPHeader"}},"insecureSkipVerify":{"type":"boolean"},"method":{"type":"string"},"successCondition":{"type":"string"},"timeoutSeconds":{"type":"integer","format":"int64"},"url":{"type":"string"}}},"v1alpha1.HTTPBodySource":{"properties":{"bytes":{"type":"string"}}},"v1alpha1.HTTPHeader":{"required":["name"],"properties":{"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPHeaderSource"}}},"v1alpha1.HTTPHeaderSource":{"properties":{"secretKeyRef":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.UserContainer":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"mirrorVolumeMounts":{"type":"boolean"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.Inputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Memoize":{"required":["key","cache","maxAge"],"properties":{"cache":{"$ref":"#/components/schemas/v1alpha1.Cache"},"key":{"type":"string"},"maxAge":{"type":"string"}}},"v1alpha1.Cache":{"required":["configMap"],"properties":{"configMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"}}},"v1alpha1.Outputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"exitCode":{"type":"string"},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}},"result":{"type":"string"}}},"v1alpha1.Plugin":{},"v1alpha1.ResourceTemplate":{"required":["action"],"properties":{"action":{"type":"string"},"failureCondition":{"type":"string"},"flags":{"type":"array","items":{"type":"string"}},"manifest":{"type":"string"},"manifestFrom":{"$ref":"#/components/schemas/v1alpha1.ManifestFrom"},"mergeStrategy":{"type":"string"},"setOwnerReference":{"type":"boolean"},"successCondition":{"type":"string"}}},"v1alpha1.ManifestFrom":{"required":["artifact"],"properties":{"artifact":{"$ref":"#/components/schemas/v1alpha1.Artifact"}}},"v1alpha1.ScriptTemplate":{"description":"A single application container that you want to run within a pod.","required":["name","source"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"source":{"type":"string"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.ParallelSteps":{},"v1alpha1.SuspendTemplate":{"properties":{"duration":{"type":"string"}}},"v1.Toleration":{"description":"The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .","properties":{"effect":{"description":"Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.","type":"string"},"key":{"description":"Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.","type":"string"},"operator":{"description":"Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.","type":"string"},"tolerationSeconds":{"description":"TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.","type":"integer","format":"int64"},"value":{"description":"Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.","type":"string"}}},"v1.Volume":{"description":"Volume represents a named volume in a pod that may be accessed by any container in the pod.","required":["name"],"properties":{"awsElasticBlockStore":{"description":"awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","$ref":"#/components/schemas/v1.AWSElasticBlockStoreVolumeSource"},"azureDisk":{"description":"azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureDiskVolumeSource"},"azureFile":{"description":"azureFile represents an Azure File Service mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureFileVolumeSource"},"cephfs":{"description":"cephFS represents a Ceph FS mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.CephFSVolumeSource"},"cinder":{"description":"cinder represents a cinder volume attached and mounted on kubelets host machine. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","$ref":"#/components/schemas/v1.CinderVolumeSource"},"configMap":{"description":"configMap represents a configMap that should populate this volume","$ref":"#/components/schemas/v1.ConfigMapVolumeSource"},"csi":{"description":"csi (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers (Beta feature).","$ref":"#/components/schemas/v1.CSIVolumeSource"},"downwardAPI":{"description":"downwardAPI represents downward API about the pod that should populate this volume","$ref":"#/components/schemas/v1.DownwardAPIVolumeSource"},"emptyDir":{"description":"emptyDir represents a temporary directory that shares a pod's lifetime. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","$ref":"#/components/schemas/v1.EmptyDirVolumeSource"},"ephemeral":{"description":"ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed.\n\nUse this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity\n tracking are needed,\nc) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through\n a PersistentVolumeClaim (see EphemeralVolumeSource for more\n information on the connection between this volume type\n and PersistentVolumeClaim).\n\nUse PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod.\n\nUse CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information.\n\nA pod can use both types of ephemeral volumes and persistent volumes at the same time.","$ref":"#/components/schemas/v1.EphemeralVolumeSource"},"fc":{"description":"fc represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.","$ref":"#/components/schemas/v1.FCVolumeSource"},"flexVolume":{"description":"flexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","$ref":"#/components/schemas/v1.FlexVolumeSource"},"flocker":{"description":"flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running","$ref":"#/components/schemas/v1.FlockerVolumeSource"},"gcePersistentDisk":{"description":"gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","$ref":"#/components/schemas/v1.GCEPersistentDiskVolumeSource"},"gitRepo":{"description":"gitRepo represents a git repository at a particular revision. DEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","$ref":"#/components/schemas/v1.GitRepoVolumeSource"},"glusterfs":{"description":"glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/glusterfs/README.md","$ref":"#/components/schemas/v1.GlusterfsVolumeSource"},"hostPath":{"description":"hostPath represents a pre-existing file or directory on the host machine that is directly exposed to the container. This is generally used for system agents or other privileged things that are allowed to see the host machine. Most containers will NOT need this. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","$ref":"#/components/schemas/v1.HostPathVolumeSource"},"iscsi":{"description":"iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://examples.k8s.io/volumes/iscsi/README.md","$ref":"#/components/schemas/v1.ISCSIVolumeSource"},"name":{"description":"name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"nfs":{"description":"nfs represents an NFS mount on the host that shares a pod's lifetime More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","$ref":"#/components/schemas/v1.NFSVolumeSource"},"persistentVolumeClaim":{"description":"persistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimVolumeSource"},"photonPersistentDisk":{"description":"photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PhotonPersistentDiskVolumeSource"},"portworxVolume":{"description":"portworxVolume represents a portworx volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PortworxVolumeSource"},"projected":{"description":"projected items for all in one resources secrets, configmaps, and downward API","$ref":"#/components/schemas/v1.ProjectedVolumeSource"},"quobyte":{"description":"quobyte represents a Quobyte mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.QuobyteVolumeSource"},"rbd":{"description":"rbd represents a Rados Block Device mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/rbd/README.md","$ref":"#/components/schemas/v1.RBDVolumeSource"},"scaleIO":{"description":"scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.ScaleIOVolumeSource"},"secret":{"description":"secret represents a secret that should populate this volume. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","$ref":"#/components/schemas/v1.SecretVolumeSource"},"storageos":{"description":"storageOS represents a StorageOS volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.StorageOSVolumeSource"},"vsphereVolume":{"description":"vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.VsphereVirtualDiskVolumeSource"}}},"v1.AWSElasticBlockStoreVolumeSource":{"description":"Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).","type":"integer","format":"int32"},"readOnly":{"description":"readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"boolean"},"volumeID":{"description":"volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"}}},"v1.AzureDiskVolumeSource":{"description":"AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","required":["diskName","diskURI"],"properties":{"cachingMode":{"description":"cachingMode is the Host Caching mode: None, Read Only, Read Write.","type":"string"},"diskName":{"description":"diskName is the Name of the data disk in the blob storage","type":"string"},"diskURI":{"description":"diskURI is the URI of data disk in the blob storage","type":"string"},"fsType":{"description":"fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"kind":{"description":"kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"}}},"v1.AzureFileVolumeSource":{"description":"AzureFile represents an Azure File Service mount on the host and bind mount to the pod.","required":["secretName","shareName"],"properties":{"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretName":{"description":"secretName is the name of secret that contains Azure Storage Account Name and Key","type":"string"},"shareName":{"description":"shareName is the azure share Name","type":"string"}}},"v1.CephFSVolumeSource":{"description":"Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.","required":["monitors"],"properties":{"monitors":{"description":"monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"path":{"description":"path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /","type":"string"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"boolean"},"secretFile":{"description":"secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"},"secretRef":{"description":"secretRef is Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"}}},"v1.CinderVolumeSource":{"description":"Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"boolean"},"secretRef":{"description":"secretRef is optional: points to a secret object containing parameters used to connect to OpenStack.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeID":{"description":"volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"}}},"v1.ConfigMapVolumeSource":{"description":"Adapts a ConfigMap into a volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.KeyToPath":{"description":"Maps a string key to a path within a volume.","required":["key","path"],"properties":{"key":{"description":"key is the key to project.","type":"string"},"mode":{"description":"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.","type":"string"}}},"v1.CSIVolumeSource":{"description":"Represents a source location of a volume to mount, managed by an external CSI driver","required":["driver"],"properties":{"driver":{"description":"driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.","type":"string"},"fsType":{"description":"fsType to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.","type":"string"},"nodePublishSecretRef":{"description":"nodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secret references are passed.","$ref":"#/components/schemas/v1.LocalObjectReference"},"readOnly":{"description":"readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).","type":"boolean"},"volumeAttributes":{"description":"volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.","type":"object","additionalProperties":{"type":"string"}}}},"v1.DownwardAPIVolumeSource":{"description":"DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"Items is a list of downward API volume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.DownwardAPIVolumeFile":{"description":"DownwardAPIVolumeFile represents information to create the file containing the pod field","required":["path"],"properties":{"fieldRef":{"description":"Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"mode":{"description":"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'","type":"string"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"}}},"v1.EmptyDirVolumeSource":{"description":"Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.","properties":{"medium":{"description":"medium represents what type of storage medium should back this directory. The default is \"\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","type":"string"},"sizeLimit":{"description":"sizeLimit is the total amount of local storage required for this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. The default is nil which means that the limit is undefined. More info: http://kubernetes.io/docs/user-guide/volumes#emptydir","$ref":"#/components/schemas/resource.Quantity"}}},"v1.EphemeralVolumeSource":{"description":"Represents an ephemeral volume that is handled by a normal storage driver.","properties":{"volumeClaimTemplate":{"description":"Will be used to create a stand-alone PVC to provision the volume. The pod in which this EphemeralVolumeSource is embedded will be the owner of the PVC, i.e. the PVC will be deleted together with the pod. The name of the PVC will be `-` where `` is the name from the `PodSpec.Volumes` array entry. Pod validation will reject the pod if the concatenated name is not valid for a PVC (for example, too long).\n\nAn existing PVC with that name that is not owned by the pod will *not* be used for the pod to avoid using an unrelated volume by mistake. Starting the pod is then blocked until the unrelated PVC is removed. If such a pre-created PVC is meant to be used by the pod, the PVC has to updated with an owner reference to the pod once the pod exists. Normally this should not be necessary, but it may be useful when manually reconstructing a broken cluster.\n\nThis field is read-only and no changes will be made by Kubernetes to the PVC after it has been created.\n\nRequired, must not be nil.","$ref":"#/components/schemas/v1.PersistentVolumeClaimTemplate"}}},"v1.PersistentVolumeClaimTemplate":{"description":"PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.","required":["spec"],"properties":{"metadata":{"description":"May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"The specification for the PersistentVolumeClaim. The entire content is copied unchanged into the PVC that gets created from this template. The same fields as in a PersistentVolumeClaim are also valid here.","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"}}},"v1.ObjectMeta":{"description":"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.","properties":{"annotations":{"description":"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations","type":"object","additionalProperties":{"type":"string"}},"clusterName":{"description":"Deprecated: ClusterName is a legacy field that was always cleared by the system and never used; it will be removed completely in 1.25.\n\nThe name in the go struct is changed to help clients detect accidental use.","type":"string"},"creationTimestamp":{"description":"CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"deletionGracePeriodSeconds":{"description":"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.","type":"integer","format":"int64"},"deletionTimestamp":{"description":"DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"finalizers":{"description":"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.","type":"array","items":{"type":"string"}},"generateName":{"description":"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency","type":"string"},"generation":{"description":"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.","type":"integer","format":"int64"},"labels":{"description":"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels","type":"object","additionalProperties":{"type":"string"}},"managedFields":{"description":"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.","type":"array","items":{"$ref":"#/components/schemas/v1.ManagedFieldsEntry"}},"name":{"description":"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"namespace":{"description":"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces","type":"string"},"ownerReferences":{"description":"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.","type":"array","items":{"$ref":"#/components/schemas/v1.OwnerReference"}},"resourceVersion":{"description":"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency","type":"string"},"selfLink":{"description":"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.","type":"string"},"uid":{"description":"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}},"v1.ManagedFieldsEntry":{"description":"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.","properties":{"apiVersion":{"description":"APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.","type":"string"},"fieldsType":{"description":"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"","type":"string"},"fieldsV1":{"description":"FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type.","$ref":"#/components/schemas/v1.FieldsV1"},"manager":{"description":"Manager is an identifier of the workflow managing these fields.","type":"string"},"operation":{"description":"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.","type":"string"},"subresource":{"description":"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.","type":"string"},"time":{"description":"Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over.","$ref":"#/components/schemas/v1.Time"}}},"v1.FieldsV1":{"description":"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff"},"v1.OwnerReference":{"description":"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.","required":["apiVersion","kind","name","uid"],"properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"blockOwnerDeletion":{"description":"If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.","type":"boolean"},"controller":{"description":"If true, this reference points to the managing controller.","type":"boolean"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"uid":{"description":"UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.PersistentVolumeClaimSpec":{"description":"PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes","properties":{"accessModes":{"description":"accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"dataSource":{"description":"dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"dataSourceRef":{"description":"dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"resources":{"description":"resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources","$ref":"#/components/schemas/v1.ResourceRequirements"},"selector":{"description":"selector is a label query over volumes to consider for binding.","$ref":"#/components/schemas/v1.LabelSelector"},"storageClassName":{"description":"storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1","type":"string"},"volumeMode":{"description":"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.","type":"string"},"volumeName":{"description":"volumeName is the binding reference to the PersistentVolume backing this claim.","type":"string"}}},"v1.TypedLocalObjectReference":{"description":"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.","required":["apiGroup","kind","name"],"properties":{"apiGroup":{"description":"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.","type":"string"},"kind":{"description":"Kind is the type of resource being referenced","type":"string"},"name":{"description":"Name is the name of resource being referenced","type":"string"}}},"v1.FCVolumeSource":{"description":"Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"lun":{"description":"lun is Optional: FC target lun number","type":"integer","format":"int32"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"targetWWNs":{"description":"targetWWNs is Optional: FC target worldwide names (WWNs)","type":"array","items":{"type":"string"}},"wwids":{"description":"wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.","type":"array","items":{"type":"string"}}}},"v1.FlexVolumeSource":{"description":"FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","required":["driver"],"properties":{"driver":{"description":"driver is the name of the driver to use for this volume.","type":"string"},"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.","type":"string"},"options":{"description":"options is Optional: this field holds extra command options if any.","type":"object","additionalProperties":{"type":"string"}},"readOnly":{"description":"readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef is Optional: secretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts.","$ref":"#/components/schemas/v1.LocalObjectReference"}}},"v1.FlockerVolumeSource":{"description":"Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.","properties":{"datasetName":{"description":"datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated","type":"string"},"datasetUUID":{"description":"datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset","type":"string"}}},"v1.GCEPersistentDiskVolumeSource":{"description":"Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.","required":["pdName"],"properties":{"fsType":{"description":"fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"integer","format":"int32"},"pdName":{"description":"pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"boolean"}}},"v1.GitRepoVolumeSource":{"description":"Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","required":["repository"],"properties":{"directory":{"description":"directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.","type":"string"},"repository":{"description":"repository is the URL","type":"string"},"revision":{"description":"revision is the commit hash for the specified revision.","type":"string"}}},"v1.GlusterfsVolumeSource":{"description":"Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.","required":["endpoints","path"],"properties":{"endpoints":{"description":"endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"path":{"description":"path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"readOnly":{"description":"readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"boolean"}}},"v1.HostPathVolumeSource":{"description":"Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.","required":["path"],"properties":{"path":{"description":"path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"},"type":{"description":"type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"}}},"v1.ISCSIVolumeSource":{"description":"Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.","required":["targetPortal","iqn","lun"],"properties":{"chapAuthDiscovery":{"description":"chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication","type":"boolean"},"chapAuthSession":{"description":"chapAuthSession defines whether support iSCSI Session CHAP authentication","type":"boolean"},"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi","type":"string"},"initiatorName":{"description":"initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.","type":"string"},"iqn":{"description":"iqn is the target iSCSI Qualified Name.","type":"string"},"iscsiInterface":{"description":"iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).","type":"string"},"lun":{"description":"lun represents iSCSI Target Lun number.","type":"integer","format":"int32"},"portals":{"description":"portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"array","items":{"type":"string"}},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.","type":"boolean"},"secretRef":{"description":"secretRef is the CHAP Secret for iSCSI target and initiator authentication","$ref":"#/components/schemas/v1.LocalObjectReference"},"targetPortal":{"description":"targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"string"}}},"v1.NFSVolumeSource":{"description":"Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.","required":["server","path"],"properties":{"path":{"description":"path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"},"readOnly":{"description":"readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"boolean"},"server":{"description":"server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"}}},"v1.PersistentVolumeClaimVolumeSource":{"description":"PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).","required":["claimName"],"properties":{"claimName":{"description":"claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","type":"string"},"readOnly":{"description":"readOnly Will force the ReadOnly setting in VolumeMounts. Default false.","type":"boolean"}}},"v1.PhotonPersistentDiskVolumeSource":{"description":"Represents a Photon Controller persistent disk resource.","required":["pdID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"pdID":{"description":"pdID is the ID that identifies Photon Controller persistent disk","type":"string"}}},"v1.PortworxVolumeSource":{"description":"PortworxVolumeSource represents a Portworx volume resource.","required":["volumeID"],"properties":{"fsType":{"description":"fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"volumeID":{"description":"volumeID uniquely identifies a Portworx volume","type":"string"}}},"v1.ProjectedVolumeSource":{"description":"Represents a projected volume source","required":["sources"],"properties":{"defaultMode":{"description":"defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"sources":{"description":"sources is the list of volume projections","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeProjection"}}}},"v1.VolumeProjection":{"description":"Projection that may be projected along with other supported volume types","properties":{"configMap":{"description":"configMap information about the configMap data to project","$ref":"#/components/schemas/v1.ConfigMapProjection"},"downwardAPI":{"description":"downwardAPI information about the downwardAPI data to project","$ref":"#/components/schemas/v1.DownwardAPIProjection"},"secret":{"description":"secret information about the secret data to project","$ref":"#/components/schemas/v1.SecretProjection"},"serviceAccountToken":{"description":"serviceAccountToken is information about the serviceAccountToken data to project","$ref":"#/components/schemas/v1.ServiceAccountTokenProjection"}}},"v1.ConfigMapProjection":{"description":"Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.DownwardAPIProjection":{"description":"Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.","properties":{"items":{"description":"Items is a list of DownwardAPIVolume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.SecretProjection":{"description":"Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional field specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.ServiceAccountTokenProjection":{"description":"ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).","required":["path"],"properties":{"audience":{"description":"audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.","type":"string"},"expirationSeconds":{"description":"expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.","type":"integer","format":"int64"},"path":{"description":"path is the path relative to the mount point of the file to project the token into.","type":"string"}}},"v1.QuobyteVolumeSource":{"description":"Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.","required":["registry","volume"],"properties":{"group":{"description":"group to map volume access to Default is no group","type":"string"},"readOnly":{"description":"readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.","type":"boolean"},"registry":{"description":"registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes","type":"string"},"tenant":{"description":"tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin","type":"string"},"user":{"description":"user to map volume access to Defaults to serivceaccount user","type":"string"},"volume":{"description":"volume is a string that references an already created Quobyte volume by name.","type":"string"}}},"v1.RBDVolumeSource":{"description":"Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.","required":["monitors","image"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd","type":"string"},"image":{"description":"image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"keyring":{"description":"keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"monitors":{"description":"monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"pool":{"description":"pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"boolean"},"secretRef":{"description":"secretRef is name of the authentication secret for RBDUser. If provided overrides keyring. Default is nil. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"}}},"v1.ScaleIOVolumeSource":{"description":"ScaleIOVolumeSource represents a persistent ScaleIO volume","required":["gateway","system","secretRef"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\".","type":"string"},"gateway":{"description":"gateway is the host address of the ScaleIO API Gateway.","type":"string"},"protectionDomain":{"description":"protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef references to the secret for ScaleIO user and other sensitive information. If this is not provided, Login operation will fail.","$ref":"#/components/schemas/v1.LocalObjectReference"},"sslEnabled":{"description":"sslEnabled Flag enable/disable SSL communication with Gateway, default false","type":"boolean"},"storageMode":{"description":"storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.","type":"string"},"storagePool":{"description":"storagePool is the ScaleIO Storage Pool associated with the protection domain.","type":"string"},"system":{"description":"system is the name of the storage system as configured in ScaleIO.","type":"string"},"volumeName":{"description":"volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.","type":"string"}}},"v1.SecretVolumeSource":{"description":"Adapts a Secret into a volume.\n\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"optional":{"description":"optional field specify whether the Secret or its keys must be defined","type":"boolean"},"secretName":{"description":"secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","type":"string"}}},"v1.StorageOSVolumeSource":{"description":"Represents a StorageOS persistent volume resource.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeName":{"description":"volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.","type":"string"},"volumeNamespace":{"description":"volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.","type":"string"}}},"v1.VsphereVirtualDiskVolumeSource":{"description":"Represents a vSphere volume resource.","required":["volumePath"],"properties":{"fsType":{"description":"fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"storagePolicyID":{"description":"storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.","type":"string"},"storagePolicyName":{"description":"storagePolicyName is the storage Policy Based Management (SPBM) profile name.","type":"string"},"volumePath":{"description":"volumePath is the path that identifies vSphere volume vmdk","type":"string"}}},"v1alpha1.TTLStrategy":{"properties":{"secondsAfterCompletion":{"type":"integer","format":"int32"},"secondsAfterFailure":{"type":"integer","format":"int32"},"secondsAfterSuccess":{"type":"integer","format":"int32"}}},"v1alpha1.VolumeClaimGC":{"properties":{"strategy":{"type":"string"}}},"v1.PersistentVolumeClaim":{"description":"PersistentVolumeClaim is a user's request for and claim to a persistent volume","properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"description":"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"spec defines the desired characteristics of a volume requested by a pod author. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"},"status":{"description":"status represents the current information/status of a persistent volume claim. Read-only. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimStatus"}}},"v1.PersistentVolumeClaimStatus":{"description":"PersistentVolumeClaimStatus is the current status of a persistent volume claim.","properties":{"accessModes":{"description":"accessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"allocatedResources":{"description":"allocatedResources is the storage resource within AllocatedResources tracks the capacity allocated to a PVC. It may be larger than the actual capacity when a volume expansion operation is requested. For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. If a volume expansion capacity request is lowered, allocatedResources is only lowered if there are no expansion operations in progress and if the actual volume capacity is equal or lower than the requested capacity. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"capacity":{"description":"capacity represents the actual resources of the underlying volume.","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"conditions":{"description":"conditions is the current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'ResizeStarted'.","type":"array","items":{"$ref":"#/components/schemas/v1.PersistentVolumeClaimCondition"}},"phase":{"description":"phase represents the current phase of PersistentVolumeClaim.","type":"string"},"resizeStatus":{"description":"resizeStatus stores status of resize operation. ResizeStatus is not set by default but when expansion is complete resizeStatus is set to empty string by resize controller or kubelet. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.","type":"string"}}},"v1.PersistentVolumeClaimCondition":{"description":"PersistentVolumeClaimCondition contails details about state of pvc","required":["type","status"],"properties":{"lastProbeTime":{"description":"lastProbeTime is the time we probed the condition.","$ref":"#/components/schemas/v1.Time"},"lastTransitionTime":{"description":"lastTransitionTime is the time the condition transitioned from one status to another.","$ref":"#/components/schemas/v1.Time"},"message":{"description":"message is the human-readable message indicating details about last transition.","type":"string"},"reason":{"description":"reason is a unique, this should be a short, machine understandable string that gives the reason for condition's last transition. If it reports \"ResizeStarted\" that means the underlying persistent volume is being resized.","type":"string"},"status":{"type":"string"},"type":{"type":"string"}}},"v1alpha1.WorkflowMetadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}},"labelsFrom":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LabelValueFrom"}}}},"v1alpha1.LabelValueFrom":{"required":["expression"],"properties":{"expression":{"type":"string"}}},"v1alpha1.WorkflowTemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"}}}}}} ``` ## The v1alpha1.WorkflowStatus object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.WorkflowStatus":{"properties":{"artifactGCStatus":{"$ref":"#/components/schemas/v1alpha1.ArtGCStatus"},"artifactRepositoryRef":{"$ref":"#/components/schemas/v1alpha1.ArtifactRepositoryRefStatus"},"compressedNodes":{"type":"string"},"conditions":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Condition"}},"estimatedDuration":{"type":"integer","format":"int32"},"finishedAt":{"$ref":"#/components/schemas/v1.Time"},"message":{"type":"string"},"nodes":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.NodeStatus"}},"offloadNodeStatusVersion":{"type":"string"},"outputs":{"$ref":"#/components/schemas/v1alpha1.Outputs"},"persistentVolumeClaims":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}},"phase":{"type":"string"},"progress":{"type":"string"},"resourcesDuration":{"type":"object","additionalProperties":{"type":"integer"}},"startedAt":{"$ref":"#/components/schemas/v1.Time"},"storedTemplates":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.Template"}},"storedWorkflowTemplateSpec":{"$ref":"#/components/schemas/v1alpha1.WorkflowSpec"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.SynchronizationStatus"},"taskResultsCompletionStatus":{"type":"object","additionalProperties":{"type":"boolean"}}}},"v1alpha1.ArtGCStatus":{"properties":{"notSpecified":{"type":"boolean"},"podsRecouped":{"type":"object","additionalProperties":{"type":"boolean"}},"strategiesProcessed":{"type":"object","additionalProperties":{"type":"boolean"}}}},"v1alpha1.ArtifactRepositoryRefStatus":{"properties":{"artifactRepository":{"$ref":"#/components/schemas/v1alpha1.ArtifactRepository"},"configMap":{"type":"string"},"default":{"type":"boolean"},"key":{"type":"string"},"namespace":{"type":"string"}}},"v1alpha1.ArtifactRepository":{"properties":{"archiveLogs":{"type":"boolean"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifactRepository"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifactRepository"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifactRepository"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifactRepository"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifactRepository"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3ArtifactRepository"}}},"v1alpha1.ArtifactoryArtifactRepository":{"properties":{"keyFormat":{"type":"string"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repoURL":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.SecretKeySelector":{"description":"SecretKeySelector selects a key of a Secret.","required":["key"],"properties":{"key":{"description":"The key of the secret to select from. Must be a valid secret key.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret or its key must be defined","type":"boolean"}}},"v1alpha1.AzureArtifactRepository":{"required":["endpoint","container"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blobNameFormat":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifactRepository":{"properties":{"bucket":{"type":"string"},"keyFormat":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifactRepository":{"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"pathFormat":{"type":"string"}}},"v1.ConfigMapKeySelector":{"description":"Selects a key from a ConfigMap.","required":["key"],"properties":{"key":{"description":"The key to select.","type":"string"},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap or its key must be defined","type":"boolean"}}},"v1alpha1.OSSArtifactRepository":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"keyFormat":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.OSSLifecycleRule":{"properties":{"markDeletionAfterDays":{"type":"integer","format":"int32"},"markInfrequentAccessAfterDays":{"type":"integer","format":"int32"}}},"v1alpha1.S3ArtifactRepository":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"keyFormat":{"type":"string"},"keyPrefix":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.CreateS3BucketOptions":{"properties":{"objectLocking":{"type":"boolean"}}},"v1alpha1.S3EncryptionOptions":{"properties":{"enableEncryption":{"type":"boolean"},"kmsEncryptionContext":{"type":"string"},"kmsKeyId":{"type":"string"},"serverSideCustomerKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.Condition":{"properties":{"message":{"type":"string"},"status":{"type":"string"},"type":{"type":"string"}}},"v1.Time":{"required":["Time"],"properties":{"Time":{"type":"string","format":"date-time"}}},"v1alpha1.NodeStatus":{"required":["id","name","type"],"properties":{"boundaryID":{"type":"string"},"children":{"type":"array","items":{"type":"string"}},"daemoned":{"type":"boolean"},"displayName":{"type":"string"},"estimatedDuration":{"type":"integer","format":"int32"},"finishedAt":{"$ref":"#/components/schemas/v1.Time"},"hostNodeName":{"type":"string"},"id":{"type":"string"},"inputs":{"$ref":"#/components/schemas/v1alpha1.Inputs"},"memoizationStatus":{"$ref":"#/components/schemas/v1alpha1.MemoizationStatus"},"message":{"type":"string"},"name":{"type":"string"},"nodeFlag":{"$ref":"#/components/schemas/v1alpha1.NodeFlag"},"outboundNodes":{"type":"array","items":{"type":"string"}},"outputs":{"$ref":"#/components/schemas/v1alpha1.Outputs"},"phase":{"type":"string"},"podIP":{"type":"string"},"progress":{"type":"string"},"resourcesDuration":{"type":"object","additionalProperties":{"type":"integer"}},"startedAt":{"$ref":"#/components/schemas/v1.Time"},"synchronizationStatus":{"$ref":"#/components/schemas/v1alpha1.NodeSynchronizationStatus"},"templateName":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"},"templateScope":{"type":"string"},"type":{"type":"string"}}},"v1alpha1.Inputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.Artifact":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.ArchiveStrategy":{"properties":{"none":{"$ref":"#/components/schemas/v1alpha1.NoneStrategy"},"tar":{"$ref":"#/components/schemas/v1alpha1.TarStrategy"},"zip":{"$ref":"#/components/schemas/v1alpha1.ZipStrategy"}}},"v1alpha1.NoneStrategy":{},"v1alpha1.TarStrategy":{"properties":{"compressionLevel":{"type":"integer","format":"int32"}}},"v1alpha1.ZipStrategy":{},"v1alpha1.ArtifactGC":{"properties":{"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.Metadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}}}},"v1alpha1.ArtifactoryArtifact":{"required":["url"],"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"url":{"type":"string"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.AzureArtifact":{"required":["endpoint","container","blob"],"properties":{"accountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"blob":{"type":"string"},"container":{"type":"string"},"endpoint":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.GCSArtifact":{"required":["key"],"properties":{"bucket":{"type":"string"},"key":{"type":"string"},"serviceAccountKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.GitArtifact":{"required":["repo"],"properties":{"branch":{"type":"string"},"depth":{"type":"integer","format":"integer"},"disableSubmodules":{"type":"boolean"},"fetch":{"type":"array","items":{"type":"string"}},"insecureIgnoreHostKey":{"type":"boolean"},"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"repo":{"type":"string"},"revision":{"type":"string"},"singleBranch":{"type":"boolean"},"sshPrivateKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.HDFSArtifact":{"required":["path"],"properties":{"addresses":{"type":"array","items":{"type":"string"}},"force":{"type":"boolean"},"hdfsUser":{"type":"string"},"krbCCacheSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbConfigConfigMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"krbKeytabSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"krbRealm":{"type":"string"},"krbServicePrincipalName":{"type":"string"},"krbUsername":{"type":"string"},"path":{"type":"string"}}},"v1alpha1.HTTPArtifact":{"required":["url"],"properties":{"auth":{"$ref":"#/components/schemas/v1alpha1.HTTPAuth"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Header"}},"url":{"type":"string"}}},"v1alpha1.HTTPAuth":{"properties":{"basicAuth":{"$ref":"#/components/schemas/v1alpha1.BasicAuth"},"clientCert":{"$ref":"#/components/schemas/v1alpha1.ClientCertAuth"},"oauth2":{"$ref":"#/components/schemas/v1alpha1.OAuth2Auth"}}},"v1alpha1.BasicAuth":{"properties":{"passwordSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"usernameSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.ClientCertAuth":{"properties":{"clientCertSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2Auth":{"properties":{"clientIDSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"clientSecretSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"endpointParams":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.OAuth2EndpointParam"}},"scopes":{"type":"array","items":{"type":"string"}},"tokenURLSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.OAuth2EndpointParam":{"required":["key"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Header":{"required":["name","value"],"properties":{"name":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.OSSArtifact":{"required":["key"],"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"createBucketIfNotPresent":{"type":"boolean"},"endpoint":{"type":"string"},"key":{"type":"string"},"lifecycleRule":{"$ref":"#/components/schemas/v1alpha1.OSSLifecycleRule"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"securityToken":{"type":"string"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.RawArtifact":{"required":["data"],"properties":{"data":{"type":"string"}}},"v1alpha1.S3Artifact":{"properties":{"accessKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"bucket":{"type":"string"},"caSecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"createBucketIfNotPresent":{"$ref":"#/components/schemas/v1alpha1.CreateS3BucketOptions"},"encryptionOptions":{"$ref":"#/components/schemas/v1alpha1.S3EncryptionOptions"},"endpoint":{"type":"string"},"insecure":{"type":"boolean"},"key":{"type":"string"},"region":{"type":"string"},"roleARN":{"type":"string"},"secretKeySecret":{"$ref":"#/components/schemas/v1.SecretKeySelector"},"useSDKCreds":{"type":"boolean"}}},"v1alpha1.Parameter":{"required":["name"],"properties":{"default":{"type":"string"},"description":{"type":"string"},"enum":{"type":"array","items":{"type":"string"}},"globalName":{"type":"string"},"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.ValueFrom"}}},"v1alpha1.ValueFrom":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"default":{"type":"string"},"event":{"type":"string"},"expression":{"type":"string"},"jqFilter":{"type":"string"},"jsonPath":{"type":"string"},"parameter":{"type":"string"},"path":{"type":"string"},"supplied":{"$ref":"#/components/schemas/v1alpha1.SuppliedValueFrom"}}},"v1alpha1.SuppliedValueFrom":{},"v1alpha1.MemoizationStatus":{"required":["hit","key","cacheName"],"properties":{"cacheName":{"type":"string"},"hit":{"type":"boolean"},"key":{"type":"string"}}},"v1alpha1.NodeFlag":{"properties":{"hooked":{"type":"boolean"},"retried":{"type":"boolean"}}},"v1alpha1.Outputs":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"exitCode":{"type":"string"},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}},"result":{"type":"string"}}},"v1alpha1.NodeSynchronizationStatus":{"properties":{"waiting":{"type":"string"}}},"v1alpha1.TemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"},"template":{"type":"string"}}},"v1.Volume":{"description":"Volume represents a named volume in a pod that may be accessed by any container in the pod.","required":["name"],"properties":{"awsElasticBlockStore":{"description":"awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","$ref":"#/components/schemas/v1.AWSElasticBlockStoreVolumeSource"},"azureDisk":{"description":"azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureDiskVolumeSource"},"azureFile":{"description":"azureFile represents an Azure File Service mount on the host and bind mount to the pod.","$ref":"#/components/schemas/v1.AzureFileVolumeSource"},"cephfs":{"description":"cephFS represents a Ceph FS mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.CephFSVolumeSource"},"cinder":{"description":"cinder represents a cinder volume attached and mounted on kubelets host machine. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","$ref":"#/components/schemas/v1.CinderVolumeSource"},"configMap":{"description":"configMap represents a configMap that should populate this volume","$ref":"#/components/schemas/v1.ConfigMapVolumeSource"},"csi":{"description":"csi (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers (Beta feature).","$ref":"#/components/schemas/v1.CSIVolumeSource"},"downwardAPI":{"description":"downwardAPI represents downward API about the pod that should populate this volume","$ref":"#/components/schemas/v1.DownwardAPIVolumeSource"},"emptyDir":{"description":"emptyDir represents a temporary directory that shares a pod's lifetime. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","$ref":"#/components/schemas/v1.EmptyDirVolumeSource"},"ephemeral":{"description":"ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed.\n\nUse this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity\n tracking are needed,\nc) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through\n a PersistentVolumeClaim (see EphemeralVolumeSource for more\n information on the connection between this volume type\n and PersistentVolumeClaim).\n\nUse PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod.\n\nUse CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information.\n\nA pod can use both types of ephemeral volumes and persistent volumes at the same time.","$ref":"#/components/schemas/v1.EphemeralVolumeSource"},"fc":{"description":"fc represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.","$ref":"#/components/schemas/v1.FCVolumeSource"},"flexVolume":{"description":"flexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","$ref":"#/components/schemas/v1.FlexVolumeSource"},"flocker":{"description":"flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running","$ref":"#/components/schemas/v1.FlockerVolumeSource"},"gcePersistentDisk":{"description":"gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","$ref":"#/components/schemas/v1.GCEPersistentDiskVolumeSource"},"gitRepo":{"description":"gitRepo represents a git repository at a particular revision. DEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","$ref":"#/components/schemas/v1.GitRepoVolumeSource"},"glusterfs":{"description":"glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/glusterfs/README.md","$ref":"#/components/schemas/v1.GlusterfsVolumeSource"},"hostPath":{"description":"hostPath represents a pre-existing file or directory on the host machine that is directly exposed to the container. This is generally used for system agents or other privileged things that are allowed to see the host machine. Most containers will NOT need this. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","$ref":"#/components/schemas/v1.HostPathVolumeSource"},"iscsi":{"description":"iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://examples.k8s.io/volumes/iscsi/README.md","$ref":"#/components/schemas/v1.ISCSIVolumeSource"},"name":{"description":"name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"nfs":{"description":"nfs represents an NFS mount on the host that shares a pod's lifetime More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","$ref":"#/components/schemas/v1.NFSVolumeSource"},"persistentVolumeClaim":{"description":"persistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimVolumeSource"},"photonPersistentDisk":{"description":"photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PhotonPersistentDiskVolumeSource"},"portworxVolume":{"description":"portworxVolume represents a portworx volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.PortworxVolumeSource"},"projected":{"description":"projected items for all in one resources secrets, configmaps, and downward API","$ref":"#/components/schemas/v1.ProjectedVolumeSource"},"quobyte":{"description":"quobyte represents a Quobyte mount on the host that shares a pod's lifetime","$ref":"#/components/schemas/v1.QuobyteVolumeSource"},"rbd":{"description":"rbd represents a Rados Block Device mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/rbd/README.md","$ref":"#/components/schemas/v1.RBDVolumeSource"},"scaleIO":{"description":"scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.ScaleIOVolumeSource"},"secret":{"description":"secret represents a secret that should populate this volume. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","$ref":"#/components/schemas/v1.SecretVolumeSource"},"storageos":{"description":"storageOS represents a StorageOS volume attached and mounted on Kubernetes nodes.","$ref":"#/components/schemas/v1.StorageOSVolumeSource"},"vsphereVolume":{"description":"vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine","$ref":"#/components/schemas/v1.VsphereVirtualDiskVolumeSource"}}},"v1.AWSElasticBlockStoreVolumeSource":{"description":"Represents a Persistent Disk resource in AWS.\n\nAn AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).","type":"integer","format":"int32"},"readOnly":{"description":"readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"boolean"},"volumeID":{"description":"volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore","type":"string"}}},"v1.AzureDiskVolumeSource":{"description":"AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.","required":["diskName","diskURI"],"properties":{"cachingMode":{"description":"cachingMode is the Host Caching mode: None, Read Only, Read Write.","type":"string"},"diskName":{"description":"diskName is the Name of the data disk in the blob storage","type":"string"},"diskURI":{"description":"diskURI is the URI of data disk in the blob storage","type":"string"},"fsType":{"description":"fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"kind":{"description":"kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"}}},"v1.AzureFileVolumeSource":{"description":"AzureFile represents an Azure File Service mount on the host and bind mount to the pod.","required":["secretName","shareName"],"properties":{"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretName":{"description":"secretName is the name of secret that contains Azure Storage Account Name and Key","type":"string"},"shareName":{"description":"shareName is the azure share Name","type":"string"}}},"v1.CephFSVolumeSource":{"description":"Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.","required":["monitors"],"properties":{"monitors":{"description":"monitors is Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"path":{"description":"path is Optional: Used as the mounted root, rather than the full Ceph tree, default is /","type":"string"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"boolean"},"secretFile":{"description":"secretFile is Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"},"secretRef":{"description":"secretRef is Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it","type":"string"}}},"v1.LocalObjectReference":{"description":"LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"}}},"v1.CinderVolumeSource":{"description":"Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.","required":["volumeID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"boolean"},"secretRef":{"description":"secretRef is optional: points to a secret object containing parameters used to connect to OpenStack.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeID":{"description":"volumeID used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md","type":"string"}}},"v1.ConfigMapVolumeSource":{"description":"Adapts a ConfigMap into a volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.KeyToPath":{"description":"Maps a string key to a path within a volume.","required":["key","path"],"properties":{"key":{"description":"key is the key to project.","type":"string"},"mode":{"description":"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'.","type":"string"}}},"v1.CSIVolumeSource":{"description":"Represents a source location of a volume to mount, managed by an external CSI driver","required":["driver"],"properties":{"driver":{"description":"driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster.","type":"string"},"fsType":{"description":"fsType to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply.","type":"string"},"nodePublishSecretRef":{"description":"nodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secret references are passed.","$ref":"#/components/schemas/v1.LocalObjectReference"},"readOnly":{"description":"readOnly specifies a read-only configuration for the volume. Defaults to false (read/write).","type":"boolean"},"volumeAttributes":{"description":"volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values.","type":"object","additionalProperties":{"type":"string"}}}},"v1.DownwardAPIVolumeSource":{"description":"DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"Items is a list of downward API volume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.DownwardAPIVolumeFile":{"description":"DownwardAPIVolumeFile represents information to create the file containing the pod field","required":["path"],"properties":{"fieldRef":{"description":"Required: Selects a field of the pod: only annotations, labels, name and namespace are supported.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"mode":{"description":"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"path":{"description":"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..'","type":"string"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"}}},"v1.ObjectFieldSelector":{"description":"ObjectFieldSelector selects an APIVersioned field of an object.","required":["fieldPath"],"properties":{"apiVersion":{"description":"Version of the schema the FieldPath is written in terms of, defaults to \"v1\".","type":"string"},"fieldPath":{"description":"Path of the field to select in the specified API version.","type":"string"}}},"v1.ResourceFieldSelector":{"description":"ResourceFieldSelector represents container resources (cpu, memory) and their output format","required":["resource"],"properties":{"containerName":{"description":"Container name: required for volumes, optional for env vars","type":"string"},"divisor":{"description":"Specifies the output format of the exposed resources, defaults to \"1\"","$ref":"#/components/schemas/resource.Quantity"},"resource":{"description":"Required: resource to select","type":"string"}}},"resource.Quantity":{"required":["i","d","s","Format"],"properties":{"Format":{"type":"string"},"d":{"$ref":"#/components/schemas/resource.infDecAmount"},"i":{"$ref":"#/components/schemas/resource.int64Amount"},"s":{"type":"string"}}},"resource.infDecAmount":{"required":["Dec"],"properties":{"Dec":{"$ref":"#/components/schemas/inf.Dec"}}},"inf.Dec":{"required":["unscaled","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"unscaled":{"$ref":"#/components/schemas/big.Int"}}},"big.Int":{"required":["neg","abs"],"properties":{"abs":{"type":"array","items":{"type":"integer","format":"integer"}},"neg":{"type":"boolean"}}},"resource.int64Amount":{"required":["value","scale"],"properties":{"scale":{"type":"integer","format":"int32"},"value":{"type":"integer","format":"int64"}}},"v1.EmptyDirVolumeSource":{"description":"Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.","properties":{"medium":{"description":"medium represents what type of storage medium should back this directory. The default is \"\" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir","type":"string"},"sizeLimit":{"description":"sizeLimit is the total amount of local storage required for this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. The default is nil which means that the limit is undefined. More info: http://kubernetes.io/docs/user-guide/volumes#emptydir","$ref":"#/components/schemas/resource.Quantity"}}},"v1.EphemeralVolumeSource":{"description":"Represents an ephemeral volume that is handled by a normal storage driver.","properties":{"volumeClaimTemplate":{"description":"Will be used to create a stand-alone PVC to provision the volume. The pod in which this EphemeralVolumeSource is embedded will be the owner of the PVC, i.e. the PVC will be deleted together with the pod. The name of the PVC will be `-` where `` is the name from the `PodSpec.Volumes` array entry. Pod validation will reject the pod if the concatenated name is not valid for a PVC (for example, too long).\n\nAn existing PVC with that name that is not owned by the pod will *not* be used for the pod to avoid using an unrelated volume by mistake. Starting the pod is then blocked until the unrelated PVC is removed. If such a pre-created PVC is meant to be used by the pod, the PVC has to updated with an owner reference to the pod once the pod exists. Normally this should not be necessary, but it may be useful when manually reconstructing a broken cluster.\n\nThis field is read-only and no changes will be made by Kubernetes to the PVC after it has been created.\n\nRequired, must not be nil.","$ref":"#/components/schemas/v1.PersistentVolumeClaimTemplate"}}},"v1.PersistentVolumeClaimTemplate":{"description":"PersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.","required":["spec"],"properties":{"metadata":{"description":"May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"The specification for the PersistentVolumeClaim. The entire content is copied unchanged into the PVC that gets created from this template. The same fields as in a PersistentVolumeClaim are also valid here.","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"}}},"v1.ObjectMeta":{"description":"ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.","properties":{"annotations":{"description":"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations","type":"object","additionalProperties":{"type":"string"}},"clusterName":{"description":"Deprecated: ClusterName is a legacy field that was always cleared by the system and never used; it will be removed completely in 1.25.\n\nThe name in the go struct is changed to help clients detect accidental use.","type":"string"},"creationTimestamp":{"description":"CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.\n\nPopulated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"deletionGracePeriodSeconds":{"description":"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only.","type":"integer","format":"int64"},"deletionTimestamp":{"description":"DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.\n\nPopulated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.Time"},"finalizers":{"description":"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list.","type":"array","items":{"type":"string"}},"generateName":{"description":"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will return a 409.\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency","type":"string"},"generation":{"description":"A sequence number representing a specific generation of the desired state. Populated by the system. Read-only.","type":"integer","format":"int64"},"labels":{"description":"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels","type":"object","additionalProperties":{"type":"string"}},"managedFields":{"description":"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like \"ci-cd\". The set of fields is always in the version that the workflow used when modifying the object.","type":"array","items":{"$ref":"#/components/schemas/v1.ManagedFieldsEntry"}},"name":{"description":"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"namespace":{"description":"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces","type":"string"},"ownerReferences":{"description":"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.","type":"array","items":{"$ref":"#/components/schemas/v1.OwnerReference"}},"resourceVersion":{"description":"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.\n\nPopulated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency","type":"string"},"selfLink":{"description":"Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.","type":"string"},"uid":{"description":"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.\n\nPopulated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.ManagedFieldsEntry":{"description":"ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to.","properties":{"apiVersion":{"description":"APIVersion defines the version of this resource that this field set applies to. The format is \"group/version\" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted.","type":"string"},"fieldsType":{"description":"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: \"FieldsV1\"","type":"string"},"fieldsV1":{"description":"FieldsV1 holds the first JSON version format as described in the \"FieldsV1\" type.","$ref":"#/components/schemas/v1.FieldsV1"},"manager":{"description":"Manager is an identifier of the workflow managing these fields.","type":"string"},"operation":{"description":"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'.","type":"string"},"subresource":{"description":"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource.","type":"string"},"time":{"description":"Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over.","$ref":"#/components/schemas/v1.Time"}}},"v1.FieldsV1":{"description":"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format.\n\nEach key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined in sigs.k8s.io/structured-merge-diff"},"v1.OwnerReference":{"description":"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field.","required":["apiVersion","kind","name","uid"],"properties":{"apiVersion":{"description":"API version of the referent.","type":"string"},"blockOwnerDeletion":{"description":"If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned.","type":"boolean"},"controller":{"description":"If true, this reference points to the managing controller.","type":"boolean"},"kind":{"description":"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"name":{"description":"Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"},"uid":{"description":"UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids","type":"string"}}},"v1.PersistentVolumeClaimSpec":{"description":"PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes","properties":{"accessModes":{"description":"accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"dataSource":{"description":"dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"dataSourceRef":{"description":"dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef\n allows any non-core object, as well as PersistentVolumeClaim objects.\n* While DataSource ignores disallowed values (dropping them), DataSourceRef\n preserves all values, and generates an error if a disallowed value is\n specified.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.","$ref":"#/components/schemas/v1.TypedLocalObjectReference"},"resources":{"description":"resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources","$ref":"#/components/schemas/v1.ResourceRequirements"},"selector":{"description":"selector is a label query over volumes to consider for binding.","$ref":"#/components/schemas/v1.LabelSelector"},"storageClassName":{"description":"storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1","type":"string"},"volumeMode":{"description":"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec.","type":"string"},"volumeName":{"description":"volumeName is the binding reference to the PersistentVolume backing this claim.","type":"string"}}},"v1.TypedLocalObjectReference":{"description":"TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.","required":["apiGroup","kind","name"],"properties":{"apiGroup":{"description":"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required.","type":"string"},"kind":{"description":"Kind is the type of resource being referenced","type":"string"},"name":{"description":"Name is the name of resource being referenced","type":"string"}}},"v1.ResourceRequirements":{"description":"ResourceRequirements describes the compute resource requirements.","properties":{"limits":{"description":"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"requests":{"description":"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}}}},"v1.LabelSelector":{"description":"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","type":"array","items":{"$ref":"#/components/schemas/v1.LabelSelectorRequirement"}},"matchLabels":{"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object","additionalProperties":{"type":"string"}}}},"v1.LabelSelectorRequirement":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.FCVolumeSource":{"description":"Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"lun":{"description":"lun is Optional: FC target lun number","type":"integer","format":"int32"},"readOnly":{"description":"readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"targetWWNs":{"description":"targetWWNs is Optional: FC target worldwide names (WWNs)","type":"array","items":{"type":"string"}},"wwids":{"description":"wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously.","type":"array","items":{"type":"string"}}}},"v1.FlexVolumeSource":{"description":"FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.","required":["driver"],"properties":{"driver":{"description":"driver is the name of the driver to use for this volume.","type":"string"},"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script.","type":"string"},"options":{"description":"options is Optional: this field holds extra command options if any.","type":"object","additionalProperties":{"type":"string"}},"readOnly":{"description":"readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef is Optional: secretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts.","$ref":"#/components/schemas/v1.LocalObjectReference"}}},"v1.FlockerVolumeSource":{"description":"Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling.","properties":{"datasetName":{"description":"datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated","type":"string"},"datasetUUID":{"description":"datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset","type":"string"}}},"v1.GCEPersistentDiskVolumeSource":{"description":"Represents a Persistent Disk resource in Google Compute Engine.\n\nA GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.","required":["pdName"],"properties":{"fsType":{"description":"fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"partition":{"description":"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"integer","format":"int32"},"pdName":{"description":"pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk","type":"boolean"}}},"v1.GitRepoVolumeSource":{"description":"Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.","required":["repository"],"properties":{"directory":{"description":"directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name.","type":"string"},"repository":{"description":"repository is the URL","type":"string"},"revision":{"description":"revision is the commit hash for the specified revision.","type":"string"}}},"v1.GlusterfsVolumeSource":{"description":"Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.","required":["endpoints","path"],"properties":{"endpoints":{"description":"endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"path":{"description":"path is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"string"},"readOnly":{"description":"readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod","type":"boolean"}}},"v1.HostPathVolumeSource":{"description":"Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.","required":["path"],"properties":{"path":{"description":"path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"},"type":{"description":"type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath","type":"string"}}},"v1.ISCSIVolumeSource":{"description":"Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.","required":["targetPortal","iqn","lun"],"properties":{"chapAuthDiscovery":{"description":"chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication","type":"boolean"},"chapAuthSession":{"description":"chapAuthSession defines whether support iSCSI Session CHAP authentication","type":"boolean"},"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi","type":"string"},"initiatorName":{"description":"initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection.","type":"string"},"iqn":{"description":"iqn is the target iSCSI Qualified Name.","type":"string"},"iscsiInterface":{"description":"iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).","type":"string"},"lun":{"description":"lun represents iSCSI Target Lun number.","type":"integer","format":"int32"},"portals":{"description":"portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"array","items":{"type":"string"}},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.","type":"boolean"},"secretRef":{"description":"secretRef is the CHAP Secret for iSCSI target and initiator authentication","$ref":"#/components/schemas/v1.LocalObjectReference"},"targetPortal":{"description":"targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).","type":"string"}}},"v1.NFSVolumeSource":{"description":"Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.","required":["server","path"],"properties":{"path":{"description":"path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"},"readOnly":{"description":"readOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"boolean"},"server":{"description":"server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs","type":"string"}}},"v1.PersistentVolumeClaimVolumeSource":{"description":"PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system).","required":["claimName"],"properties":{"claimName":{"description":"claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","type":"string"},"readOnly":{"description":"readOnly Will force the ReadOnly setting in VolumeMounts. Default false.","type":"boolean"}}},"v1.PhotonPersistentDiskVolumeSource":{"description":"Represents a Photon Controller persistent disk resource.","required":["pdID"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"pdID":{"description":"pdID is the ID that identifies Photon Controller persistent disk","type":"string"}}},"v1.PortworxVolumeSource":{"description":"PortworxVolumeSource represents a Portworx volume resource.","required":["volumeID"],"properties":{"fsType":{"description":"fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"volumeID":{"description":"volumeID uniquely identifies a Portworx volume","type":"string"}}},"v1.ProjectedVolumeSource":{"description":"Represents a projected volume source","required":["sources"],"properties":{"defaultMode":{"description":"defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"sources":{"description":"sources is the list of volume projections","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeProjection"}}}},"v1.VolumeProjection":{"description":"Projection that may be projected along with other supported volume types","properties":{"configMap":{"description":"configMap information about the configMap data to project","$ref":"#/components/schemas/v1.ConfigMapProjection"},"downwardAPI":{"description":"downwardAPI information about the downwardAPI data to project","$ref":"#/components/schemas/v1.DownwardAPIProjection"},"secret":{"description":"secret information about the secret data to project","$ref":"#/components/schemas/v1.SecretProjection"},"serviceAccountToken":{"description":"serviceAccountToken is information about the serviceAccountToken data to project","$ref":"#/components/schemas/v1.ServiceAccountTokenProjection"}}},"v1.ConfigMapProjection":{"description":"Adapts a ConfigMap into a projected volume.\n\nThe contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional specify whether the ConfigMap or its keys must be defined","type":"boolean"}}},"v1.DownwardAPIProjection":{"description":"Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.","properties":{"items":{"description":"Items is a list of DownwardAPIVolume file","type":"array","items":{"$ref":"#/components/schemas/v1.DownwardAPIVolumeFile"}}}},"v1.SecretProjection":{"description":"Adapts a secret into a projected volume.\n\nThe contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode.","properties":{"items":{"description":"items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"optional field specify whether the Secret or its key must be defined","type":"boolean"}}},"v1.ServiceAccountTokenProjection":{"description":"ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).","required":["path"],"properties":{"audience":{"description":"audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver.","type":"string"},"expirationSeconds":{"description":"expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes.","type":"integer","format":"int64"},"path":{"description":"path is the path relative to the mount point of the file to project the token into.","type":"string"}}},"v1.QuobyteVolumeSource":{"description":"Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.","required":["registry","volume"],"properties":{"group":{"description":"group to map volume access to Default is no group","type":"string"},"readOnly":{"description":"readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false.","type":"boolean"},"registry":{"description":"registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes","type":"string"},"tenant":{"description":"tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin","type":"string"},"user":{"description":"user to map volume access to Defaults to serivceaccount user","type":"string"},"volume":{"description":"volume is a string that references an already created Quobyte volume by name.","type":"string"}}},"v1.RBDVolumeSource":{"description":"Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.","required":["monitors","image"],"properties":{"fsType":{"description":"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd","type":"string"},"image":{"description":"image is the rados image name. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"keyring":{"description":"keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"monitors":{"description":"monitors is a collection of Ceph monitors. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"array","items":{"type":"string"}},"pool":{"description":"pool is the rados pool name. Default is rbd. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"},"readOnly":{"description":"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"boolean"},"secretRef":{"description":"secretRef is name of the authentication secret for RBDUser. If provided overrides keyring. Default is nil. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","$ref":"#/components/schemas/v1.LocalObjectReference"},"user":{"description":"user is the rados user name. Default is admin. More info: https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it","type":"string"}}},"v1.ScaleIOVolumeSource":{"description":"ScaleIOVolumeSource represents a persistent ScaleIO volume","required":["gateway","system","secretRef"],"properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Default is \"xfs\".","type":"string"},"gateway":{"description":"gateway is the host address of the ScaleIO API Gateway.","type":"string"},"protectionDomain":{"description":"protectionDomain is the name of the ScaleIO Protection Domain for the configured storage.","type":"string"},"readOnly":{"description":"readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef references to the secret for ScaleIO user and other sensitive information. If this is not provided, Login operation will fail.","$ref":"#/components/schemas/v1.LocalObjectReference"},"sslEnabled":{"description":"sslEnabled Flag enable/disable SSL communication with Gateway, default false","type":"boolean"},"storageMode":{"description":"storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned.","type":"string"},"storagePool":{"description":"storagePool is the ScaleIO Storage Pool associated with the protection domain.","type":"string"},"system":{"description":"system is the name of the storage system as configured in ScaleIO.","type":"string"},"volumeName":{"description":"volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source.","type":"string"}}},"v1.SecretVolumeSource":{"description":"Adapts a Secret into a volume.\n\nThe contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling.","properties":{"defaultMode":{"description":"defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set.","type":"integer","format":"int32"},"items":{"description":"items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'.","type":"array","items":{"$ref":"#/components/schemas/v1.KeyToPath"}},"optional":{"description":"optional field specify whether the Secret or its keys must be defined","type":"boolean"},"secretName":{"description":"secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret","type":"string"}}},"v1.StorageOSVolumeSource":{"description":"Represents a StorageOS persistent volume resource.","properties":{"fsType":{"description":"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"readOnly":{"description":"readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts.","type":"boolean"},"secretRef":{"description":"secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted.","$ref":"#/components/schemas/v1.LocalObjectReference"},"volumeName":{"description":"volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace.","type":"string"},"volumeNamespace":{"description":"volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created.","type":"string"}}},"v1.VsphereVirtualDiskVolumeSource":{"description":"Represents a vSphere volume resource.","required":["volumePath"],"properties":{"fsType":{"description":"fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified.","type":"string"},"storagePolicyID":{"description":"storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName.","type":"string"},"storagePolicyName":{"description":"storagePolicyName is the storage Policy Based Management (SPBM) profile name.","type":"string"},"volumePath":{"description":"volumePath is the path that identifies vSphere volume vmdk","type":"string"}}},"v1alpha1.Template":{"properties":{"activeDeadlineSeconds":{"$ref":"#/components/schemas/intstr.IntOrString"},"affinity":{"$ref":"#/components/schemas/v1.Affinity"},"archiveLocation":{"$ref":"#/components/schemas/v1alpha1.ArtifactLocation"},"automountServiceAccountToken":{"type":"boolean"},"container":{"$ref":"#/components/schemas/v1.Container"},"containerSet":{"$ref":"#/components/schemas/v1alpha1.ContainerSetTemplate"},"daemon":{"type":"boolean"},"dag":{"$ref":"#/components/schemas/v1alpha1.DAGTemplate"},"data":{"$ref":"#/components/schemas/v1alpha1.Data"},"executor":{"$ref":"#/components/schemas/v1alpha1.ExecutorConfig"},"failFast":{"type":"boolean"},"hostAliases":{"type":"array","items":{"$ref":"#/components/schemas/v1.HostAlias"}},"http":{"$ref":"#/components/schemas/v1alpha1.HTTP"},"initContainers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"inputs":{"$ref":"#/components/schemas/v1alpha1.Inputs"},"memoize":{"$ref":"#/components/schemas/v1alpha1.Memoize"},"metadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"metrics":{"$ref":"#/components/schemas/v1alpha1.Metrics"},"name":{"type":"string"},"nodeSelector":{"type":"object","additionalProperties":{"type":"string"}},"outputs":{"$ref":"#/components/schemas/v1alpha1.Outputs"},"parallelism":{"type":"integer","format":"int64"},"plugin":{"$ref":"#/components/schemas/v1alpha1.Plugin"},"podSpecPatch":{"type":"string"},"priority":{"type":"integer","format":"int32"},"priorityClassName":{"type":"string"},"resource":{"$ref":"#/components/schemas/v1alpha1.ResourceTemplate"},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.RetryStrategy"},"schedulerName":{"type":"string"},"script":{"$ref":"#/components/schemas/v1alpha1.ScriptTemplate"},"securityContext":{"$ref":"#/components/schemas/v1.PodSecurityContext"},"serviceAccountName":{"type":"string"},"sidecars":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.UserContainer"}},"steps":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ParallelSteps"}},"suspend":{"$ref":"#/components/schemas/v1alpha1.SuspendTemplate"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.Synchronization"},"timeout":{"type":"string"},"tolerations":{"type":"array","items":{"$ref":"#/components/schemas/v1.Toleration"}},"volumes":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}}}},"intstr.IntOrString":{"required":["Type","IntVal","StrVal"],"properties":{"IntVal":{"type":"integer","format":"int32"},"StrVal":{"type":"string"},"Type":{"type":"integer","format":"int64"}}},"v1.Affinity":{"description":"Affinity is a group of affinity scheduling rules.","properties":{"nodeAffinity":{"description":"Describes node affinity scheduling rules for the pod.","$ref":"#/components/schemas/v1.NodeAffinity"},"podAffinity":{"description":"Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAffinity"},"podAntiAffinity":{"description":"Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).","$ref":"#/components/schemas/v1.PodAntiAffinity"}}},"v1.NodeAffinity":{"description":"Node affinity is a group of node affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.PreferredSchedulingTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.","$ref":"#/components/schemas/v1.NodeSelector"}}},"v1.PreferredSchedulingTerm":{"description":"An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).","required":["weight","preference"],"properties":{"preference":{"description":"A node selector term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.NodeSelectorTerm"},"weight":{"description":"Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.NodeSelectorTerm":{"description":"A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.","properties":{"matchExpressions":{"description":"A list of node selector requirements by node's labels.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}},"matchFields":{"description":"A list of node selector requirements by node's fields.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorRequirement"}}}},"v1.NodeSelectorRequirement":{"description":"A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","required":["key","operator"],"properties":{"key":{"description":"The label key that the selector applies to.","type":"string"},"operator":{"description":"Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.","type":"string"},"values":{"description":"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.","type":"array","items":{"type":"string"}}}},"v1.NodeSelector":{"description":"A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms.","required":["nodeSelectorTerms"],"properties":{"nodeSelectorTerms":{"description":"Required. A list of node selector terms. The terms are ORed.","type":"array","items":{"$ref":"#/components/schemas/v1.NodeSelectorTerm"}}}},"v1.PodAffinity":{"description":"Pod affinity is a group of inter pod affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1.WeightedPodAffinityTerm":{"description":"The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)","required":["weight","podAffinityTerm"],"properties":{"podAffinityTerm":{"description":"Required. A pod affinity term, associated with the corresponding weight.","$ref":"#/components/schemas/v1.PodAffinityTerm"},"weight":{"description":"weight associated with matching the corresponding podAffinityTerm, in the range 1-100.","type":"integer","format":"int32"}}},"v1.PodAffinityTerm":{"description":"Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running","required":["topologyKey"],"properties":{"labelSelector":{"description":"A label query over a set of resources, in this case pods.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaceSelector":{"description":"A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means \"this pod's namespace\". An empty selector ({}) matches all namespaces.","$ref":"#/components/schemas/v1.LabelSelector"},"namespaces":{"description":"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means \"this pod's namespace\".","type":"array","items":{"type":"string"}},"topologyKey":{"description":"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.","type":"string"}}},"v1.PodAntiAffinity":{"description":"Pod anti affinity is a group of inter pod anti affinity scheduling rules.","properties":{"preferredDuringSchedulingIgnoredDuringExecution":{"description":"The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.","type":"array","items":{"$ref":"#/components/schemas/v1.WeightedPodAffinityTerm"}},"requiredDuringSchedulingIgnoredDuringExecution":{"description":"If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.","type":"array","items":{"$ref":"#/components/schemas/v1.PodAffinityTerm"}}}},"v1alpha1.ArtifactLocation":{"properties":{"archiveLogs":{"type":"boolean"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"}}},"v1.Container":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1.EnvVar":{"description":"EnvVar represents an environment variable present in a Container.","required":["name"],"properties":{"name":{"description":"Name of the environment variable. Must be a C_IDENTIFIER.","type":"string"},"value":{"description":"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\".","type":"string"},"valueFrom":{"description":"Source for the environment variable's value. Cannot be used if value is not empty.","$ref":"#/components/schemas/v1.EnvVarSource"}}},"v1.EnvVarSource":{"description":"EnvVarSource represents a source for the value of an EnvVar.","properties":{"configMapKeyRef":{"description":"Selects a key of a ConfigMap.","$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"fieldRef":{"description":"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.","$ref":"#/components/schemas/v1.ObjectFieldSelector"},"resourceFieldRef":{"description":"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.","$ref":"#/components/schemas/v1.ResourceFieldSelector"},"secretKeyRef":{"description":"Selects a key of a secret in the pod's namespace","$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1.EnvFromSource":{"description":"EnvFromSource represents the source of a set of ConfigMaps","properties":{"configMapRef":{"description":"The ConfigMap to select from","$ref":"#/components/schemas/v1.ConfigMapEnvSource"},"prefix":{"description":"An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.","type":"string"},"secretRef":{"description":"The Secret to select from","$ref":"#/components/schemas/v1.SecretEnvSource"}}},"v1.ConfigMapEnvSource":{"description":"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.\n\nThe contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the ConfigMap must be defined","type":"boolean"}}},"v1.SecretEnvSource":{"description":"SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.","properties":{"name":{"description":"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names","type":"string"},"optional":{"description":"Specify whether the Secret must be defined","type":"boolean"}}},"v1.Lifecycle":{"description":"Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.","properties":{"postStart":{"description":"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"},"preStop":{"description":"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks","$ref":"#/components/schemas/v1.LifecycleHandler"}}},"v1.LifecycleHandler":{"description":"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"tcpSocket":{"description":"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.","$ref":"#/components/schemas/v1.TCPSocketAction"}}},"v1.ExecAction":{"description":"ExecAction describes a \"run in container\" action.","properties":{"command":{"description":"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.","type":"array","items":{"type":"string"}}}},"v1.HTTPGetAction":{"description":"HTTPGetAction describes an action based on HTTP Get requests.","required":["port"],"properties":{"host":{"description":"Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.","type":"string"},"httpHeaders":{"description":"Custom headers to set in the request. HTTP allows repeated headers.","type":"array","items":{"$ref":"#/components/schemas/v1.HTTPHeader"}},"path":{"description":"Path to access on the HTTP server.","type":"string"},"port":{"description":"Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"},"scheme":{"description":"Scheme to use for connecting to the host. Defaults to HTTP.","type":"string"}}},"v1.HTTPHeader":{"description":"HTTPHeader describes a custom header to be used in HTTP probes","required":["name","value"],"properties":{"name":{"description":"The header field name","type":"string"},"value":{"description":"The header field value","type":"string"}}},"v1.TCPSocketAction":{"description":"TCPSocketAction describes an action based on opening a socket","required":["port"],"properties":{"host":{"description":"Optional: Host name to connect to, defaults to the pod IP.","type":"string"},"port":{"description":"Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.","$ref":"#/components/schemas/intstr.IntOrString"}}},"v1.Probe":{"description":"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.","properties":{"exec":{"description":"Exec specifies the action to take.","$ref":"#/components/schemas/v1.ExecAction"},"failureThreshold":{"description":"Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.","type":"integer","format":"int32"},"grpc":{"description":"GRPC specifies an action involving a GRPC port. This is a beta field and requires enabling GRPCContainerProbe feature gate.","$ref":"#/components/schemas/v1.GRPCAction"},"httpGet":{"description":"HTTPGet specifies the http request to perform.","$ref":"#/components/schemas/v1.HTTPGetAction"},"initialDelaySeconds":{"description":"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"},"periodSeconds":{"description":"How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1.","type":"integer","format":"int32"},"successThreshold":{"description":"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.","type":"integer","format":"int32"},"tcpSocket":{"description":"TCPSocket specifies an action involving a TCP port.","$ref":"#/components/schemas/v1.TCPSocketAction"},"terminationGracePeriodSeconds":{"description":"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.","type":"integer","format":"int64"},"timeoutSeconds":{"description":"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","type":"integer","format":"int32"}}},"v1.GRPCAction":{"required":["port","service"],"properties":{"port":{"description":"Port number of the gRPC service. Number must be in the range 1 to 65535.","type":"integer","format":"int32"},"service":{"description":"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.","type":"string"}}},"v1.ContainerPort":{"description":"ContainerPort represents a network port in a single container.","required":["containerPort"],"properties":{"containerPort":{"description":"Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.","type":"integer","format":"int32"},"hostIP":{"description":"What host IP to bind the external port to.","type":"string"},"hostPort":{"description":"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.","type":"integer","format":"int32"},"name":{"description":"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services.","type":"string"},"protocol":{"description":"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".","type":"string"}}},"v1.SecurityContext":{"description":"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence.","properties":{"allowPrivilegeEscalation":{"description":"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"capabilities":{"description":"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.Capabilities"},"privileged":{"description":"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"procMount":{"description":"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"readOnlyRootFilesystem":{"description":"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows.","type":"boolean"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Capabilities":{"description":"Adds and removes POSIX capabilities from running containers.","properties":{"add":{"description":"Added capabilities","type":"array","items":{"type":"string"}},"drop":{"description":"Removed capabilities","type":"array","items":{"type":"string"}}}},"v1.SELinuxOptions":{"description":"SELinuxOptions are the labels to be applied to the container","properties":{"level":{"description":"Level is SELinux level label that applies to the container.","type":"string"},"role":{"description":"Role is a SELinux role label that applies to the container.","type":"string"},"type":{"description":"Type is a SELinux type label that applies to the container.","type":"string"},"user":{"description":"User is a SELinux user label that applies to the container.","type":"string"}}},"v1.SeccompProfile":{"description":"SeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.","required":["type"],"properties":{"localhostProfile":{"description":"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is \"Localhost\".","type":"string"},"type":{"description":"type indicates which kind of seccomp profile will be applied. Valid options are:\n\nLocalhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied.","type":"string"}}},"v1.WindowsSecurityContextOptions":{"description":"WindowsSecurityContextOptions contain Windows-specific options and credentials.","properties":{"gmsaCredentialSpec":{"description":"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.","type":"string"},"gmsaCredentialSpecName":{"description":"GMSACredentialSpecName is the name of the GMSA credential spec to use.","type":"string"},"hostProcess":{"description":"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true.","type":"boolean"},"runAsUserName":{"description":"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"string"}}},"v1.VolumeDevice":{"description":"volumeDevice describes a mapping of a raw block device within a container.","required":["name","devicePath"],"properties":{"devicePath":{"description":"devicePath is the path inside of the container that the device will be mapped to.","type":"string"},"name":{"description":"name must match the name of a persistentVolumeClaim in the pod","type":"string"}}},"v1.VolumeMount":{"description":"VolumeMount describes a mounting of a Volume within a container.","required":["name","mountPath"],"properties":{"mountPath":{"description":"Path within the container at which the volume should be mounted. Must not contain ':'.","type":"string"},"mountPropagation":{"description":"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10.","type":"string"},"name":{"description":"This must match the Name of a Volume.","type":"string"},"readOnly":{"description":"Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false.","type":"boolean"},"subPath":{"description":"Path within the volume from which the container's volume should be mounted. Defaults to \"\" (volume's root).","type":"string"},"subPathExpr":{"description":"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to \"\" (volume's root). SubPathExpr and SubPath are mutually exclusive.","type":"string"}}},"v1alpha1.ContainerSetTemplate":{"required":["containers"],"properties":{"containers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.ContainerNode"}},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.ContainerSetRetryStrategy"},"volumeMounts":{"type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}}}},"v1alpha1.ContainerNode":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"dependencies":{"type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.ContainerSetRetryStrategy":{"required":["retries"],"properties":{"duration":{"type":"string"},"retries":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"v1alpha1.DAGTemplate":{"required":["tasks"],"properties":{"failFast":{"type":"boolean"},"target":{"type":"string"},"tasks":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.DAGTask"}}}},"v1alpha1.DAGTask":{"required":["name"],"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"continueOn":{"$ref":"#/components/schemas/v1alpha1.ContinueOn"},"dependencies":{"type":"array","items":{"type":"string"}},"depends":{"type":"string"},"hooks":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LifecycleHook"}},"inline":{"$ref":"#/components/schemas/v1alpha1.Template"},"name":{"type":"string"},"onExit":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"},"when":{"type":"string"},"withItems":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Item"}},"withParam":{"type":"string"},"withSequence":{"$ref":"#/components/schemas/v1alpha1.Sequence"}}},"v1alpha1.Arguments":{"properties":{"artifacts":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Artifact"}},"parameters":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Parameter"}}}},"v1alpha1.ContinueOn":{"properties":{"error":{"type":"boolean"},"failed":{"type":"boolean"}}},"v1alpha1.LifecycleHook":{"properties":{"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"expression":{"type":"string"},"template":{"type":"string"},"templateRef":{"$ref":"#/components/schemas/v1alpha1.TemplateRef"}}},"v1alpha1.Item":{},"v1alpha1.Sequence":{"properties":{"count":{"$ref":"#/components/schemas/intstr.IntOrString"},"end":{"$ref":"#/components/schemas/intstr.IntOrString"},"format":{"type":"string"},"start":{"$ref":"#/components/schemas/intstr.IntOrString"}}},"v1alpha1.Data":{"required":["source","transformation"],"properties":{"source":{"$ref":"#/components/schemas/v1alpha1.DataSource"},"transformation":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.TransformationStep"}}}},"v1alpha1.DataSource":{"properties":{"artifactPaths":{"$ref":"#/components/schemas/v1alpha1.ArtifactPaths"}}},"v1alpha1.ArtifactPaths":{"required":["name"],"properties":{"archive":{"$ref":"#/components/schemas/v1alpha1.ArchiveStrategy"},"archiveLogs":{"type":"boolean"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.ArtifactGC"},"artifactory":{"$ref":"#/components/schemas/v1alpha1.ArtifactoryArtifact"},"azure":{"$ref":"#/components/schemas/v1alpha1.AzureArtifact"},"deleted":{"type":"boolean"},"from":{"type":"string"},"fromExpression":{"type":"string"},"gcs":{"$ref":"#/components/schemas/v1alpha1.GCSArtifact"},"git":{"$ref":"#/components/schemas/v1alpha1.GitArtifact"},"globalName":{"type":"string"},"hdfs":{"$ref":"#/components/schemas/v1alpha1.HDFSArtifact"},"http":{"$ref":"#/components/schemas/v1alpha1.HTTPArtifact"},"mode":{"type":"integer","format":"int32"},"name":{"type":"string"},"optional":{"type":"boolean"},"oss":{"$ref":"#/components/schemas/v1alpha1.OSSArtifact"},"path":{"type":"string"},"raw":{"$ref":"#/components/schemas/v1alpha1.RawArtifact"},"recurseMode":{"type":"boolean"},"s3":{"$ref":"#/components/schemas/v1alpha1.S3Artifact"},"subPath":{"type":"string"}}},"v1alpha1.TransformationStep":{"required":["expression"],"properties":{"expression":{"type":"string"}}},"v1alpha1.ExecutorConfig":{"properties":{"serviceAccountName":{"type":"string"}}},"v1.HostAlias":{"description":"HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.","properties":{"hostnames":{"description":"Hostnames for the above IP address.","type":"array","items":{"type":"string"}},"ip":{"description":"IP address of the host file entry.","type":"string"}}},"v1alpha1.HTTP":{"required":["url"],"properties":{"body":{"type":"string"},"bodyFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPBodySource"},"headers":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.HTTPHeader"}},"insecureSkipVerify":{"type":"boolean"},"method":{"type":"string"},"successCondition":{"type":"string"},"timeoutSeconds":{"type":"integer","format":"int64"},"url":{"type":"string"}}},"v1alpha1.HTTPBodySource":{"properties":{"bytes":{"type":"string"}}},"v1alpha1.HTTPHeader":{"required":["name"],"properties":{"name":{"type":"string"},"value":{"type":"string"},"valueFrom":{"$ref":"#/components/schemas/v1alpha1.HTTPHeaderSource"}}},"v1alpha1.HTTPHeaderSource":{"properties":{"secretKeyRef":{"$ref":"#/components/schemas/v1.SecretKeySelector"}}},"v1alpha1.UserContainer":{"description":"A single application container that you want to run within a pod.","required":["name"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"mirrorVolumeMounts":{"type":"boolean"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1alpha1.Memoize":{"required":["key","cache","maxAge"],"properties":{"cache":{"$ref":"#/components/schemas/v1alpha1.Cache"},"key":{"type":"string"},"maxAge":{"type":"string"}}},"v1alpha1.Cache":{"required":["configMap"],"properties":{"configMap":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"}}},"v1alpha1.Metrics":{"required":["prometheus"],"properties":{"prometheus":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Prometheus"}}}},"v1alpha1.Prometheus":{"required":["name","help"],"properties":{"counter":{"$ref":"#/components/schemas/v1alpha1.Counter"},"gauge":{"$ref":"#/components/schemas/v1alpha1.Gauge"},"help":{"type":"string"},"histogram":{"$ref":"#/components/schemas/v1alpha1.Histogram"},"labels":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MetricLabel"}},"name":{"type":"string"},"when":{"type":"string"}}},"v1alpha1.Counter":{"required":["value"],"properties":{"value":{"type":"string"}}},"v1alpha1.Gauge":{"required":["value","realtime"],"properties":{"operation":{"type":"string"},"realtime":{"type":"boolean"},"value":{"type":"string"}}},"v1alpha1.Histogram":{"required":["value","buckets"],"properties":{"buckets":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Amount"}},"value":{"type":"string"}}},"v1alpha1.Amount":{},"v1alpha1.MetricLabel":{"required":["key","value"],"properties":{"key":{"type":"string"},"value":{"type":"string"}}},"v1alpha1.Plugin":{},"v1alpha1.ResourceTemplate":{"required":["action"],"properties":{"action":{"type":"string"},"failureCondition":{"type":"string"},"flags":{"type":"array","items":{"type":"string"}},"manifest":{"type":"string"},"manifestFrom":{"$ref":"#/components/schemas/v1alpha1.ManifestFrom"},"mergeStrategy":{"type":"string"},"setOwnerReference":{"type":"boolean"},"successCondition":{"type":"string"}}},"v1alpha1.ManifestFrom":{"required":["artifact"],"properties":{"artifact":{"$ref":"#/components/schemas/v1alpha1.Artifact"}}},"v1alpha1.RetryStrategy":{"properties":{"affinity":{"$ref":"#/components/schemas/v1alpha1.RetryAffinity"},"backoff":{"$ref":"#/components/schemas/v1alpha1.Backoff"},"expression":{"type":"string"},"limit":{"$ref":"#/components/schemas/intstr.IntOrString"},"retryPolicy":{"type":"string"}}},"v1alpha1.RetryAffinity":{"properties":{"nodeAntiAffinity":{"$ref":"#/components/schemas/v1alpha1.RetryNodeAntiAffinity"}}},"v1alpha1.RetryNodeAntiAffinity":{},"v1alpha1.Backoff":{"properties":{"duration":{"type":"string"},"factor":{"$ref":"#/components/schemas/intstr.IntOrString"},"maxDuration":{"type":"string"}}},"v1alpha1.ScriptTemplate":{"description":"A single application container that you want to run within a pod.","required":["name","source"],"properties":{"args":{"description":"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"command":{"description":"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. \"$$(VAR_NAME)\" will produce the string literal \"$(VAR_NAME)\". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell","type":"array","items":{"type":"string"}},"env":{"description":"List of environment variables to set in the container. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvVar"}},"envFrom":{"description":"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.EnvFromSource"}},"image":{"description":"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets.","type":"string"},"imagePullPolicy":{"description":"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images","type":"string"},"lifecycle":{"description":"Actions that the management system should take in response to container lifecycle events. Cannot be updated.","$ref":"#/components/schemas/v1.Lifecycle"},"livenessProbe":{"description":"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"name":{"description":"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.","type":"string"},"ports":{"description":"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.ContainerPort"}},"readinessProbe":{"description":"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"resources":{"description":"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/","$ref":"#/components/schemas/v1.ResourceRequirements"},"securityContext":{"description":"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/","$ref":"#/components/schemas/v1.SecurityContext"},"source":{"type":"string"},"startupProbe":{"description":"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes","$ref":"#/components/schemas/v1.Probe"},"stdin":{"description":"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false.","type":"boolean"},"stdinOnce":{"description":"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false","type":"boolean"},"terminationMessagePath":{"description":"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated.","type":"string"},"terminationMessagePolicy":{"description":"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated.","type":"string"},"tty":{"description":"Whether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false.","type":"boolean"},"volumeDevices":{"description":"volumeDevices is the list of block devices to be used by the container.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeDevice"}},"volumeMounts":{"description":"Pod volumes to mount into the container's filesystem. Cannot be updated.","type":"array","items":{"$ref":"#/components/schemas/v1.VolumeMount"}},"workingDir":{"description":"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.","type":"string"}}},"v1.PodSecurityContext":{"description":"PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext.","properties":{"fsGroup":{"description":"A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod:\n\n1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw ","type":"integer","format":"int64"},"fsGroupChangePolicy":{"description":"fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are \"OnRootMismatch\" and \"Always\". If not specified, \"Always\" is used. Note that this field cannot be set when spec.os.name is windows.","type":"string"},"runAsGroup":{"description":"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"runAsNonRoot":{"description":"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.","type":"boolean"},"runAsUser":{"description":"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","type":"integer","format":"int64"},"seLinuxOptions":{"description":"The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SELinuxOptions"},"seccompProfile":{"description":"The seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows.","$ref":"#/components/schemas/v1.SeccompProfile"},"supplementalGroups":{"description":"A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"type":"integer","format":"int64"}},"sysctls":{"description":"Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows.","type":"array","items":{"$ref":"#/components/schemas/v1.Sysctl"}},"windowsOptions":{"description":"The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux.","$ref":"#/components/schemas/v1.WindowsSecurityContextOptions"}}},"v1.Sysctl":{"description":"Sysctl defines a kernel parameter to be set","required":["name","value"],"properties":{"name":{"description":"Name of a property to set","type":"string"},"value":{"description":"Value of a property to set","type":"string"}}},"v1alpha1.ParallelSteps":{},"v1alpha1.SuspendTemplate":{"properties":{"duration":{"type":"string"}}},"v1alpha1.Synchronization":{"properties":{"mutex":{"$ref":"#/components/schemas/v1alpha1.Mutex"},"semaphore":{"$ref":"#/components/schemas/v1alpha1.SemaphoreRef"}}},"v1alpha1.Mutex":{"properties":{"name":{"type":"string"},"namespace":{"type":"string"}}},"v1alpha1.SemaphoreRef":{"properties":{"configMapKeyRef":{"$ref":"#/components/schemas/v1.ConfigMapKeySelector"},"namespace":{"type":"string"}}},"v1.Toleration":{"description":"The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .","properties":{"effect":{"description":"Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.","type":"string"},"key":{"description":"Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.","type":"string"},"operator":{"description":"Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.","type":"string"},"tolerationSeconds":{"description":"TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.","type":"integer","format":"int64"},"value":{"description":"Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.","type":"string"}}},"v1alpha1.WorkflowSpec":{"properties":{"activeDeadlineSeconds":{"type":"integer","format":"int64"},"affinity":{"$ref":"#/components/schemas/v1.Affinity"},"archiveLogs":{"type":"boolean"},"arguments":{"$ref":"#/components/schemas/v1alpha1.Arguments"},"artifactGC":{"$ref":"#/components/schemas/v1alpha1.WorkflowLevelArtifactGC"},"artifactRepositoryRef":{"$ref":"#/components/schemas/v1alpha1.ArtifactRepositoryRef"},"automountServiceAccountToken":{"type":"boolean"},"dnsConfig":{"$ref":"#/components/schemas/v1.PodDNSConfig"},"dnsPolicy":{"type":"string"},"entrypoint":{"type":"string"},"executor":{"$ref":"#/components/schemas/v1alpha1.ExecutorConfig"},"hooks":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LifecycleHook"}},"hostAliases":{"type":"array","items":{"$ref":"#/components/schemas/v1.HostAlias"}},"hostNetwork":{"type":"boolean"},"imagePullSecrets":{"type":"array","items":{"$ref":"#/components/schemas/v1.LocalObjectReference"}},"metrics":{"$ref":"#/components/schemas/v1alpha1.Metrics"},"nodeSelector":{"type":"object","additionalProperties":{"type":"string"}},"onExit":{"type":"string"},"parallelism":{"type":"integer","format":"int64"},"podDisruptionBudget":{"$ref":"#/components/schemas/v1.PodDisruptionBudgetSpec"},"podGC":{"$ref":"#/components/schemas/v1alpha1.PodGC"},"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"podPriority":{"type":"integer","format":"int32"},"podPriorityClassName":{"type":"string"},"podSpecPatch":{"type":"string"},"priority":{"type":"integer","format":"int32"},"retryStrategy":{"$ref":"#/components/schemas/v1alpha1.RetryStrategy"},"schedulerName":{"type":"string"},"securityContext":{"$ref":"#/components/schemas/v1.PodSecurityContext"},"serviceAccountName":{"type":"string"},"shutdown":{"type":"string"},"suspend":{"type":"boolean"},"synchronization":{"$ref":"#/components/schemas/v1alpha1.Synchronization"},"templateDefaults":{"$ref":"#/components/schemas/v1alpha1.Template"},"templates":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.Template"}},"tolerations":{"type":"array","items":{"$ref":"#/components/schemas/v1.Toleration"}},"ttlStrategy":{"$ref":"#/components/schemas/v1alpha1.TTLStrategy"},"volumeClaimGC":{"$ref":"#/components/schemas/v1alpha1.VolumeClaimGC"},"volumeClaimTemplates":{"type":"array","items":{"$ref":"#/components/schemas/v1.PersistentVolumeClaim"}},"volumes":{"type":"array","items":{"$ref":"#/components/schemas/v1.Volume"}},"workflowMetadata":{"$ref":"#/components/schemas/v1alpha1.WorkflowMetadata"},"workflowTemplateRef":{"$ref":"#/components/schemas/v1alpha1.WorkflowTemplateRef"}}},"v1alpha1.WorkflowLevelArtifactGC":{"properties":{"forceFinalizerRemoval":{"type":"boolean"},"podMetadata":{"$ref":"#/components/schemas/v1alpha1.Metadata"},"podSpecPatch":{"type":"string"},"serviceAccountName":{"type":"string"},"strategy":{"type":"string"}}},"v1alpha1.ArtifactRepositoryRef":{"properties":{"configMap":{"type":"string"},"key":{"type":"string"}}},"v1.PodDNSConfig":{"description":"PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy.","properties":{"nameservers":{"description":"A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed.","type":"array","items":{"type":"string"}},"options":{"description":"A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy.","type":"array","items":{"$ref":"#/components/schemas/v1.PodDNSConfigOption"}},"searches":{"description":"A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed.","type":"array","items":{"type":"string"}}}},"v1.PodDNSConfigOption":{"description":"PodDNSConfigOption defines DNS resolver options of a pod.","properties":{"name":{"description":"Required.","type":"string"},"value":{"type":"string"}}},"v1.PodDisruptionBudgetSpec":{"description":"PodDisruptionBudgetSpec is a description of a PodDisruptionBudget.","properties":{"maxUnavailable":{"description":"An eviction is allowed if at most \"maxUnavailable\" pods selected by \"selector\" are unavailable after the eviction, i.e. even in absence of the evicted pod. For example, one can prevent all voluntary evictions by specifying 0. This is a mutually exclusive setting with \"minAvailable\".","$ref":"#/components/schemas/intstr.IntOrString"},"minAvailable":{"description":"An eviction is allowed if at least \"minAvailable\" pods selected by \"selector\" will still be available after the eviction, i.e. even in the absence of the evicted pod. So for example you can prevent all voluntary evictions by specifying \"100%\".","$ref":"#/components/schemas/intstr.IntOrString"},"selector":{"description":"Label query over pods whose evictions are managed by the disruption budget. A null selector will match no pods, while an empty ({}) selector will select all pods within the namespace.","$ref":"#/components/schemas/v1.LabelSelector"}}},"v1alpha1.PodGC":{"properties":{"deleteDelayDuration":{"type":"string"},"labelSelector":{"$ref":"#/components/schemas/v1.LabelSelector"},"strategy":{"type":"string"}}},"v1alpha1.TTLStrategy":{"properties":{"secondsAfterCompletion":{"type":"integer","format":"int32"},"secondsAfterFailure":{"type":"integer","format":"int32"},"secondsAfterSuccess":{"type":"integer","format":"int32"}}},"v1alpha1.VolumeClaimGC":{"properties":{"strategy":{"type":"string"}}},"v1.PersistentVolumeClaim":{"description":"PersistentVolumeClaim is a user's request for and claim to a persistent volume","properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"description":"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata","$ref":"#/components/schemas/v1.ObjectMeta"},"spec":{"description":"spec defines the desired characteristics of a volume requested by a pod author. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimSpec"},"status":{"description":"status represents the current information/status of a persistent volume claim. Read-only. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims","$ref":"#/components/schemas/v1.PersistentVolumeClaimStatus"}}},"v1.PersistentVolumeClaimStatus":{"description":"PersistentVolumeClaimStatus is the current status of a persistent volume claim.","properties":{"accessModes":{"description":"accessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1","type":"array","items":{"type":"string"}},"allocatedResources":{"description":"allocatedResources is the storage resource within AllocatedResources tracks the capacity allocated to a PVC. It may be larger than the actual capacity when a volume expansion operation is requested. For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. If a volume expansion capacity request is lowered, allocatedResources is only lowered if there are no expansion operations in progress and if the actual volume capacity is equal or lower than the requested capacity. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"capacity":{"description":"capacity represents the actual resources of the underlying volume.","type":"object","additionalProperties":{"$ref":"#/components/schemas/resource.Quantity"}},"conditions":{"description":"conditions is the current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'ResizeStarted'.","type":"array","items":{"$ref":"#/components/schemas/v1.PersistentVolumeClaimCondition"}},"phase":{"description":"phase represents the current phase of PersistentVolumeClaim.","type":"string"},"resizeStatus":{"description":"resizeStatus stores status of resize operation. ResizeStatus is not set by default but when expansion is complete resizeStatus is set to empty string by resize controller or kubelet. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.","type":"string"}}},"v1.PersistentVolumeClaimCondition":{"description":"PersistentVolumeClaimCondition contails details about state of pvc","required":["type","status"],"properties":{"lastProbeTime":{"description":"lastProbeTime is the time we probed the condition.","$ref":"#/components/schemas/v1.Time"},"lastTransitionTime":{"description":"lastTransitionTime is the time the condition transitioned from one status to another.","$ref":"#/components/schemas/v1.Time"},"message":{"description":"message is the human-readable message indicating details about last transition.","type":"string"},"reason":{"description":"reason is a unique, this should be a short, machine understandable string that gives the reason for condition's last transition. If it reports \"ResizeStarted\" that means the underlying persistent volume is being resized.","type":"string"},"status":{"type":"string"},"type":{"type":"string"}}},"v1alpha1.WorkflowMetadata":{"properties":{"annotations":{"type":"object","additionalProperties":{"type":"string"}},"labels":{"type":"object","additionalProperties":{"type":"string"}},"labelsFrom":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/v1alpha1.LabelValueFrom"}}}},"v1alpha1.LabelValueFrom":{"required":["expression"],"properties":{"expression":{"type":"string"}}},"v1alpha1.WorkflowTemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"}}},"v1alpha1.SynchronizationStatus":{"properties":{"mutex":{"$ref":"#/components/schemas/v1alpha1.MutexStatus"},"semaphore":{"$ref":"#/components/schemas/v1alpha1.SemaphoreStatus"}}},"v1alpha1.MutexStatus":{"properties":{"holding":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MutexHolding"}},"waiting":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.MutexHolding"}}}},"v1alpha1.MutexHolding":{"properties":{"holder":{"type":"string"},"mutex":{"type":"string"}}},"v1alpha1.SemaphoreStatus":{"properties":{"holding":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.SemaphoreHolding"}},"waiting":{"type":"array","items":{"$ref":"#/components/schemas/v1alpha1.SemaphoreHolding"}}}},"v1alpha1.SemaphoreHolding":{"properties":{"holders":{"type":"array","items":{"type":"string"}},"semaphore":{"type":"string"}}}}}} ``` ## The v1alpha1.WorkflowTemplateRef object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.WorkflowTemplateRef":{"properties":{"clusterScope":{"type":"boolean"},"name":{"type":"string"}}}}}} ``` ## The v1alpha1.ZipStrategy object ```json {"openapi":"3.1.1","components":{"schemas":{"v1alpha1.ZipStrategy":{}}}} ``` # Python SDK Using the Pipekit Python SDK The [Pipekit Python SDK](https://pypi.org/project/pipekit-sdk/) lets you talk to the Pipekit API from Python. It's the right surface for use in [Jupyter Notebooks](/reference/python-sdk/examples-jupyter), inside [Python scripts](/reference/python-sdk/examples-scripts), and for building automation against Pipekit programmatically. The SDK wraps the [REST API](/reference/rest-api) and is designed to pair well with [Hera](https://github.com/argoproj-labs/hera) for authoring workflows in Python. ## Install ```bash pip install pipekit-sdk ``` The SDK targets Python 3.10+. ## Authenticate The SDK uses a bearer token, which you generate with the [Pipekit CLI](/reference/cli): ```bash pipekit login # one-time, opens browser for SSO or prompts for password pipekit hera # prints a token to stdout ``` Pass the token to a `PipekitService`: ```python from pipekit_sdk.service import PipekitService pipekit = PipekitService(token="") ``` For longer-lived programs, set `PIPEKIT_TOKEN` and pull it from the environment: ```python import os from pipekit_sdk.service import PipekitService pipekit = PipekitService(token=os.environ["PIPEKIT_TOKEN"]) ``` ## Submit a Workflow ```python from hera.workflows import DAG, Workflow, script @script(image="python:3.12") def echo(message): print(message) with Workflow( generate_name="dag-diamond-", entrypoint="diamond", namespace="argo", service_account_name="argo-workflow", ) as w: with DAG(name="diamond"): A = echo(name="A", arguments={"message": "A"}) B = echo(name="B", arguments={"message": "B"}) C = echo(name="C", arguments={"message": "C"}) D = echo(name="D", arguments={"message": "D"}) A >> [B, C] >> D pipe_run = pipekit.submit(w, "") print(pipe_run["uuid"]) ``` `submit` returns the `pipe_run` dictionary including the Run's UUID. ## List Runs ```python runs = pipekit.list_runs(cluster_name="") for r in runs: print(r["uuid"], r["status"]) ``` Filter by Pipe, namespace, or status. See the SDK source for the full parameter list. ## Stop, terminate, or restart a Run ```python pipekit.stop(run_uuid="") pipekit.terminate(run_uuid="") pipekit.restart(run_uuid="") ``` `stop` runs exit handlers; `terminate` does not. `restart` resubmits with the same parameters and returns a new `pipe_run`. ## Stream logs ```python pipekit.print_logs(pipe_run["uuid"]) ``` For non-blocking access, use the lower-level log fetcher (see SDK source). ## CronWorkflows The SDK supports the full CronWorkflow lifecycle: ```python from hera.workflows import Container, CronWorkflow with CronWorkflow( name="cron-wf-example", namespace="argo", entrypoint="main", schedule="*/5 * * * *", concurrency_policy="Replace", service_account_name="argo-workflow", ) as cw: main = Container( name="main", image="alpine", command=["sh", "-c", "echo I am a CronWorkflow"], ) pipekit.create(cw, "") # Later: pipekit.suspend(cw) pipekit.resume(cw) pipekit.update(cw) pipekit.delete(cw) ``` ## What's next * [Jupyter Notebooks](/reference/python-sdk/examples-jupyter): a worked example with log streaming. * [Python Scripts](/reference/python-sdk/examples-scripts): a worked example of a coinflip workflow. * [REST API](/reference/rest-api): if you'd rather call the API directly. * [CLI > Using with Hera](/reference/cli/using-with-hera): token generation flow for Hera users. # Jupyter Notebooks Using the Pipekit Python SDK in Jupyter Notebooks ## Get a token Use the [Pipekit CLI](/reference/cli) to generate a token using `pipekit hera` (ensure you are logged in first). You can then pass this token to a `PipekitService`: ```py from pipekit_sdk.service import PipekitService # Create a Pipekit service that is used to talk to the Pipekit API pipekit = PipekitService(token="") ``` ## Submission Create a Workflow to submit: ```py from hera.workflows import DAG, Workflow, script @script(image="python:3.12") def echo(message): print(message) with Workflow( generate_name="dag-diamond-", entrypoint="diamond", namespace="argo", service_account_name="argo-workflow", ) as w: with DAG(name="diamond"): A = echo(name="A", arguments={"message": "A"}) B = echo(name="B", arguments={"message": "B"}) C = echo(name="C", arguments={"message": "C"}) D = echo(name="D", arguments={"message": "D"}) A >> [B, C] >> D ``` Then use `submit` to run the Workflow on Pipekit, remember to pass in your cluster name. ```py # Submit the Workflow to Pipekit pipe_run = pipekit.submit(w, "") print("pipe_run", pipe_run, "\n") ``` ## Log Streaming After you have submitted a Workflow as above, you will be holding a "pipe\_run" - you can stream the logs to your Notebook using `print_logs` on the `uuid`: ```py pipekit.print_logs(pipe_run["uuid"]) ``` # Python Scripts Using the Pipekit Python SDK in Python scripts ## Example The following example runs the [coinflip workflow](https://github.com/argoproj-labs/hera/blob/main/examples/workflows/upstream/coinflip.py) in the `argo` namespace using the `argo-workflow` service account via Pipekit. Use the [Pipekit CLI](/reference/cli) to generate a token using `pipekit hera` (ensure you are logged in first). ```python from hera.workflows import Container, Step, Steps, Workflow, script from pipekit_sdk.service import PipekitService pipekit = PipekitService(token="") @script(image="python:alpine3.6", command=["python"], add_cwd_to_sys_path=False) def flip_coin() -> None: import random result = "heads" if random.randint(0, 1) == 0 else "tails" print(result) with Workflow( generate_name="coinflip-", annotations={ "workflows.argoproj.io/description": ( "This is an example of coin flip defined as a sequence of conditional steps." ), }, entrypoint="coinflip", namespace="argo", service_account_name="argo-workflow", ) as w: heads = Container( name="heads", image="alpine:3.6", command=["sh", "-c"], args=['echo "it was heads"'], ) tails = Container( name="tails", image="alpine:3.6", command=["sh", "-c"], args=['echo "it was tails"'], ) with Steps(name="coinflip") as s: fc: Step = flip_coin() with s.parallel(): heads(when=f"{fc.result} == heads") tails(when=f"{fc.result} == tails") pipekit.submit(w, "clusterB") ``` # Helm Chart Values Helm chart values for the Pipekit Agent and self-hosted chart. Pipekit ships two Helm charts: * [Agent chart values](/reference/helm-values/agent): the `pipekit-agent` chart. * [Self-hosted chart values](/reference/helm-values/self-hosted): the self-hosted Pipekit chart. # Agent Chart ## Installation The Pipekit Agent must be installed onto each cluster where your Argo Workflow controller runs. ### Helm Install When you choose to [connect a cluster in Pipekit](/reference), you will be provided with a Secret Access Key for the cluster and a unique Cluster ID. These need to be passed to the helm chart when installing the Pipekit Agent. You should store the Secret Access Key securely in a password manager or similar. ```bash kubectl create ns argo helm repo add pipekit https://helm.pipekit.io helm upgrade -i -n argo \ pipekit-agent pipekit/pipekit-agent \ --set secrets.pipekitSecretAccessKey="[provided Secret Access Key]" \ --set secrets.pipekitClusterId="[provided Cluster ID]" ``` ### Argo CD If you are using Argo CD, you can install the Pipekit Agent using the following steps: 1. Create and push [a secret](#secrets) to your cluster containing your pipekitSecretAccessKey and pipekitClusterId 2. Create a new Argo CD Application Manifest, referencing that secret: ```yaml apiVersion: argoproj.io/v1alpha1 kind: Application metadata: name: pipekit-agent namespace: argocd finalizers: - resources-finalizer.argocd.argoproj.io spec: destination: namespace: argo server: 'https://kubernetes.default.svc' source: repoURL: 'https://helm.pipekit.io' chart: pipekit-agent targetRevision: HEAD helm: parameters: - name: secrets.existingSecret value: "pipekit-agent" project: default syncPolicy: automated: prune: true selfHeal: true syncOptions: - PrunePropagationPolicy=background - CreateNamespace=true ``` Argo CD offers other secrets management alternatives to ensure that your secrets are not stored in plaintext in your git repository. You can read more about them [in the Argo CD documentation](https://argo-cd.readthedocs.io/en/stable/operator-manual/secret-management/#secret-management). ### Release Notes Release notes are published on the [Pipekit Releases site](https://releases.pipekit.io). ## Pipekit Agent Helm Chart Values There are other optional, configurable options within the Helm Chart. These are listed below. | Key | Type | Default | Description | | ---------------------------------------------------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | configMap.additionalConfig | object | `{}` | Add any additional configMap entries to the Pipekit Agent ConfigMap. | | configMap.allowExternalWorkflows | bool | `false` | Allow Pipekit Agent to monitor workflows created without Pipekit. This is disabled by default. | | configMap.annotations | object | `{}` | Add any additional annotations to the Pipekit Agent ConfigMap. | | configMap.enableTelemetryUsersHTTPClient | bool | `false` | Should telemetry be enabled for users http client. | | configMap.enableTelemetryUsersHTTPClientEndpointInfo | bool | `false` | Should endpoint info be included in the telemetry for users http client. | | configMap.enableTelemetryWorkqueue | bool | `false` | Should telemetry be enabled for workqueue. | | configMap.externalWorkflowsMaxWorkers | int | 10 | The maximum number of workers that the Pipekit Agent can use to execute external workflows. | | configMap.logLevel | string | `"INFO"` | Set the logLevel for the Pipekit Agent. | | configMap.logSendWorkers | int | 64 | The number of workers that the Pipekit Agent can use to send logs. | | configMap.maxLogBatchSize | int | 1024 | The maximum number of logs to send in a single batch. | | configMap.messengerBaseUri | string | `https://api.pipekit.io` | Set the base URI for the Pipekit Messenger Service. Only set this if you are running a self-hosted Pipekit instance. | | configMap.podInformerWorkers | int | 8 | The number of workers that the Pipekit Agent can use to process pod consuming queue. | | configMap.sendLogsToPipekit | bool | `true` | Send Workflow logs to Pipekit. Pipekit will store and index logs for you to view at pipekit.io Refer to the Vector section to enable performant log collection when running at massive scale. | | configMap.shouldDeleteExternalWorkflows | bool | `false` | Should the Pipekit Agent delete external workflows after execution. This is set to false by default. | | configMap.telemetryProtocols | string | `"prometheus"` | set to 'none' to disable all telemetry | | configMap.usersBaseUri | string | `https://api.pipekit.io` | Set the base URI for the Pipekit Users Service. Only set this if you are running a self-hosted Pipekit instance. | | configMap.workflowInformerWorkers | int | 8 | The number of workers that the Pipekit Agent can use to process workflow consuming queue. | | customCABundle.configMapKey | string | `"root-ca.pem"` | Key in the ConfigMap that contains the CA certificate. | | customCABundle.configMapName | string | `""` | Name of the ConfigMap containing the CA certificate. | | customCABundle.enabled | bool | `false` | Enable mounting a custom CA certificate bundle. | | customCABundle.mountPath | string | `"/etc/ssl/certs/root-ca.pem"` | Path where the CA certificate will be mounted. | | deployment.affinity | object | `{}` | The Pipekit Agent pod's affinity rules. | | deployment.extraEnvFrom | list | `[]` | Extra envFrom sources (ConfigMap / Secret references) appended to the Pipekit Agent container. Useful for injecting environment from secrets managed outside the chart. | | deployment.image.imagePullSecrets | list | `[]` | Allows you to define the name of existing imagePullSecrets to use for pulling the Pipekit Agent image. | | deployment.image.pullPolicy | string | `"IfNotPresent"` | The imagePullPolicy for the Pipekit Agent image. | | deployment.image.repository | string | `"pipekit13/pipekit-agent"` | The Pipekit Agent image name and repository. Change this if you wish to host the container yourself. | | deployment.image.tag | string | `""` | Allows you to pin to a specific image tag. The Chart.yaml contains a default value. | | deployment.nodeSelector | object | `{"kubernetes.io/os":"linux"}` | The Pipekit Agent pod's node selector. | | deployment.podAnnotations | object | `{}` | Add any additional annotations to the Pipekit Agent pod. | | deployment.podLabels | object | `{}` | Add any additional labels to the Pipekit Agent pod. | | deployment.resources | object | `{}` | Set the Pipekit Agent pod's resource requests and limits. We suggest a minimal amount of resources below, but you should increase these if needed as actual resource usage will depend on usage. | | deployment.tolerations | list | `[]` | The Pipekit Agent pod's tolerations. | | features | object | `{"metrics":{"argoWfControllerLabels":{},"argoWfMetricsPath":"/metrics","argoWfMetricsPort":9090,"argoWfNamespace":"argo","collectorLogLevel":"info","collectorNodeSelector":{"kubernetes.io/os":"linux"},"collectorResources":{"requests":{"cpu":"80m","memory":"256Mi"}},"deployment":{"image":{"imagePullSecrets":[],"pullPolicy":"IfNotPresent","repository":"pipekit13/agent","tag":""},"replicas":1,"resources":{"limits":{"cpu":"200m","memory":"250Mi"},"requests":{"cpu":"10m","memory":"50Mi"}}},"enabled":false,"k8sAuthType":"","metricsCollectorUrl":"","otelCollectorImage":"","otelCollectorTag":"","pipekitApiUrl":""},"workflows":{"argoServerUrl":"","enabled":true,"namespace":"","nodeOffloading":{"argoDB":{"archiveTableName":"argo_archived_workflows","database":"","driver":"postgres","host":"","maxConnectionLifetime":5,"maxIdleConnections":15,"maxOpenConnections":30,"maxRetries":3,"offloadedNodesTableName":"argo_workflows","port":5432,"secret":{"annotations":{},"argoDBPassword":"","argoDBUsername":"","existingSecret":"","name":""},"sslMode":"disable"},"enabled":false},"stepPodsDelete":{"enabled":true}}}` | Enable and Disable features of the Pipekit Agent. | | features.metrics.argoWfControllerLabels | object | `{}` | the labels we should use to select the workflow controller. Defaults to `app: workflow-controller` if not set (suitable for the official Workflows release manifest) | | features.metrics.argoWfMetricsPath | string | `"/metrics"` | The path where your Argo Workflows controller exposes metrics. | | features.metrics.argoWfMetricsPort | int | `9090` | The port number of your Argo Workflows controller that exposes metrics. | | features.metrics.argoWfNamespace | string | `"argo"` | The namespace where your Argo Workflows controller is running. This tells Pipekit Agent where to find the Workflow metrics. | | features.metrics.collectorLogLevel | string | `"info"` | The Pipekit Agent Metrics Collector will log at this level. | | features.metrics.collectorNodeSelector | object | `{"kubernetes.io/os":"linux"}` | A nodeselector for the opentelemetry collector | | features.metrics.collectorResources | object | `{"requests":{"cpu":"80m","memory":"256Mi"}}` | Resource requests and limits for the collector | | features.metrics.deployment.image.imagePullSecrets | list | `[]` | Allows you to define the name of existing imagePullSecrets to use for pulling the Pipekit Agent Operator image. | | features.metrics.deployment.image.pullPolicy | string | `"IfNotPresent"` | The imagePullPolicy for the Pipekit Agent Operator image. | | features.metrics.deployment.image.repository | string | `"pipekit13/agent"` | The Pipekit Agent Operator image name and repository. Change this if you wish to host the container yourself. | | features.metrics.deployment.image.tag | string | `""` | Allows you to pin to a specific image tag. The Chart.yaml contains a default value. | | features.metrics.deployment.replicas | int | `1` | The number of replicas for the Pipekit Agent Metrics Collector. | | features.metrics.deployment.resources | object | `{"limits":{"cpu":"200m","memory":"250Mi"},"requests":{"cpu":"10m","memory":"50Mi"}}` | Set the Pipekit Agent Controller Manager pod's resource requests and limits. We suggest a minimal amount of resources below, but you should increase these if needed as actual resource usage will depend on usage. | | features.metrics.enabled | bool | `false` | Enable and Disable Pipekit Workflow metrics. This passes Workflow metrics from your cluster to Pipekit in order to view them in the Workflow Metrics dashboard. # [You must sign up here to use this feature](https://pipekit.io/metrics-signup) or email . # This feature requires feature.workflows.namespace to be "", for cluster wide access | | features.metrics.k8sAuthType | string | `""` | kubernetes authentication method, defaults to serviceAccount alternative setting is none | | features.metrics.metricsCollectorUrl | string | `""` | URL of the metrics collector endpoint. Only set if instructed by Pipekit support — defaults to `pipekitApiUrl`. | | features.metrics.otelCollectorImage | string | `""` | The docker name of the opentelemetry contrib collector image to deploy | | features.metrics.otelCollectorTag | string | `""` | The tag of the collector image to use | | features.metrics.pipekitApiUrl | string | `https://api.pipekit.io` | URL of the Pipekit API the metrics collector mints its workflow-metrics auth token against. Only set this if you are running a self-hosted (on-prem) Pipekit instance. | | features.workflows | object | `{"argoServerUrl":"","enabled":true,"namespace":"","nodeOffloading":{"argoDB":{"archiveTableName":"argo_archived_workflows","database":"","driver":"postgres","host":"","maxConnectionLifetime":5,"maxIdleConnections":15,"maxOpenConnections":30,"maxRetries":3,"offloadedNodesTableName":"argo_workflows","port":5432,"secret":{"annotations":{},"argoDBPassword":"","argoDBUsername":"","existingSecret":"","name":""},"sslMode":"disable"},"enabled":false},"stepPodsDelete":{"enabled":true}}` | Enable and Disable the Pipekit Agent. This communicates with the Pipekit control plane and allows you to run and manage your workflows. | | features.workflows.argoServerUrl | string | "" | The URL where your Argo Server is reachable from your users' browsers (e.g. ). Reported to Pipekit on registration and used to show artifact View / Download links in the UI. Leave empty to hide them. | | features.workflows.namespace | string | "" | Specify a single namespace where this Pipekit Agent instance will manage workflows. If empty this will work across all namespaces as a cluster wide agent | | features.workflows.nodeOffloading | object | false | Enable reading offloaded node status from Argo's database when node status offloading is configured. | | features.workflows.nodeOffloading.argoDB | object | `{"archiveTableName":"argo_archived_workflows","database":"","driver":"postgres","host":"","maxConnectionLifetime":5,"maxIdleConnections":15,"maxOpenConnections":30,"maxRetries":3,"offloadedNodesTableName":"argo_workflows","port":5432,"secret":{"annotations":{},"argoDBPassword":"","argoDBUsername":"","existingSecret":"","name":""},"sslMode":"disable"}` | Argo Workflows Database Configuration. Only required when nodeOffloading is enabled. | | features.workflows.nodeOffloading.argoDB.archiveTableName | string | "argo\_archived\_workflows" | Table name for archived workflows (must match Argo Workflows config) | | features.workflows.nodeOffloading.argoDB.database | string | `""` | Database name | | features.workflows.nodeOffloading.argoDB.driver | string | "postgres" | Database driver: "postgres" or "mysql" | | features.workflows.nodeOffloading.argoDB.host | string | `""` | Database host address | | features.workflows.nodeOffloading.argoDB.maxConnectionLifetime | int | 5 | Max db connection lifetime in minutes | | features.workflows.nodeOffloading.argoDB.maxIdleConnections | int | 15 | Max number of idle db connections | | features.workflows.nodeOffloading.argoDB.maxOpenConnections | int | 30 | Max number of open db connections | | features.workflows.nodeOffloading.argoDB.maxRetries | int | `3` | Maximum number of connection retries | | features.workflows.nodeOffloading.argoDB.offloadedNodesTableName | string | "argo\_workflows" | Table name for offloaded node status (must match Argo Workflows config) | | features.workflows.nodeOffloading.argoDB.port | int | 5432 | Database port (default: 5432 for postgres, 3306 for mysql) | | features.workflows.nodeOffloading.argoDB.secret.annotations | object | `{}` | Add any additional annotations to the ArgoWF DB Secret. Requires features.workflows.nodeOffloading.argoDB.secret.existingSecret to be blank. | | features.workflows.nodeOffloading.argoDB.secret.argoDBPassword | string | `""` | Enter the argoDBPassword for the database used by Argo Workflows. Requires features.workflows.nodeOffloading.argoDB.secret.existingSecret to be blank. | | features.workflows.nodeOffloading.argoDB.secret.argoDBUsername | string | `""` | Enter the argoDBUsername for the database used by Argo Workflows. Requires features.workflows.nodeOffloading.argoDB.secret.existingSecret to be blank. | | features.workflows.nodeOffloading.argoDB.secret.existingSecret | string | `""` | The name of an [existing secret](#secrets) containing your argoDBUsername and argoDBPassword. | | features.workflows.nodeOffloading.argoDB.secret.name | string | `""` | Specifies the name of the Secret to create. Leave blank to auto-generate a name. Requires features.workflows.nodeOffloading.argoDB.secret.existingSecret to be blank. | | features.workflows.nodeOffloading.argoDB.sslMode | string | `"disable"` | SSL mode for PostgreSQL connections (e.g., "disable", "require", "verify-full") This is ignored for MySQL connections. | | features.workflows.stepPodsDelete | object | `{"enabled":true}` | Allow Pipekit Agent to delete the Pod associated with a running Workflow Step when triggered through the Pipekit UI. If a retryStrategy is enabled in the running Workflow, this will cause the Step to be retried. | | fullnameOverride | string | `""` | Completely replace the generated name with the provided name. | | metrics.enabled | bool | `false` | Enables a Service and ServiceMonitor for Prometheus metrics. | | nameOverride | string | `""` | Replaces the name of the chart in Chart.yaml. | | secrets.annotations | object | `{}` | Add any additional annotations to the Pipekit Agent Secret. Requires secrets.existingSecret to be blank. | | secrets.existingSecret | string | `""` | The name of an [existing secret](#secrets) containing your pipekitSecretAccessKey and pipekitClusterId. | | secrets.name | string | `""` | Specifies the name of the Secret to create. Leave blank to auto-generate a name. Requires secrets.existingSecret to be blank. | | secrets.pipekitClusterId | string | `""` | Enter the pipekitClusterId provided by Pipekit when you added the cluster. Requires secrets.existingSecret to be blank. | | secrets.pipekitSecretAccessKey | string | `""` | Enter the pipekitSecretAccessKey provided by Pipekit when you added the cluster. Requires secrets.existingSecret to be blank. | | serviceAccount.annotations | object | `{}` | Add any additional annotations to the Pipekit Agent ServiceAccount and ServiceAccount Token Secret. | | serviceAccount.create | bool | `true` | Specifies whether a ServiceAccount should be created. If false, you must provide an [existing ServiceAccount name](#pipekit-agent-cluster-permissions). | | serviceAccount.name | string | `""` | Specifies the name of the ServiceAccount to create if serviceAccount.create is true. Otherwise, specifies the name of an existing ServiceAccount to use. | | vector.dataDir | string | `"/tmp"` | Path Vector writes its disk buffer to (mounted from the host's /var/lib/vector). | | vector.enabled | bool | `false` | Enable Vector for node-level log collection. When enabled, Vector runs as a DaemonSet and collects logs directly from the node filesystem for better performance. `configMap.sendLogsToPipekit` should be `false` when setting `vector.enabled` to `true` | | vector.envFrom | list | `[]` | Extra envFrom entries on the Vector DaemonSet. Leave empty to let the operator auto-mount the agent Secret — the one named by `secrets.existingSecret`, or chart-templated from `secrets.pipekitSecretAccessKey` / `secrets.pipekitClusterId` when no existing secret is provided — so Vector can read ${PIPEKIT\_SECRET\_ACCESS\_KEY}. Override here to point Vector at a different Secret. | | vector.image.pullPolicy | string | `"IfNotPresent"` | The imagePullPolicy for the Vector image. | | vector.image.pullSecrets | list | `[]` | The [imagePullSecrets](https://kubernetes.io/docs/concepts/containers/images/#specifying-imagepullsecrets-on-a-pod) to reference for the Vector Pods. | | vector.image.repository | string | `""` | The Vector image name and repository. Leave blank to use the operator default. | | vector.image.tag | string | `""` | The Vector image tag. Leave blank to use the operator default. | | vector.nodeSelector | object | `{}` | The Vector DaemonSet's node selector. Empty means schedule on every node. | | vector.resources | object | `{"requests":{"cpu":"30m","memory":"130Mi"}}` | Set Vector resource requests and limits. | | vector.tolerations | list | `[]` | Tolerations applied to the Vector DaemonSet so it can run on tainted nodes (e.g. master/control-plane). Empty means inherit the DaemonSet default (no extra tolerations). | ## Secrets If you wish to provide your own secret you need to populate it with the pipekitSecretAccessKey and pipekitClusterId values, using the defined data keys below: | Chart var | .data. in Secret | | ------------------------------ | ---------------------------- | | secrets.pipekitSecretAccessKey | PIPEKIT\_SECRET\_ACCESS\_KEY | | secrets.pipekitClusterId | PIPEKIT\_CLUSTER\_ID | eg: ```bash kubectl -n argo create secret generic pipekit-agent \ --from-literal=PIPEKIT_SECRET_ACCESS_KEY='abc123' \ --from-literal=PIPEKIT_CLUSTER_ID='123abc' ``` You must use single quotes '' to escape special characters such as $, , \*, =, and ! in your strings. If you don't, your shell will interpret these characters. ## Enabling Externally Triggered Workflows If you wish to enable [externally triggered workflows](https://github.com/pipekit/pipeline-mono/tree/gitbook/docs/reference/pipekit/pipes/externally-triggered-workflows.md), you can set the following values in your Helm install command: ```bash kubectl create ns argo helm repo add pipekit https://helm.pipekit.io helm upgrade -i -n argo \ pipekit-agent pipekit/pipekit-agent \ --set secrets.pipekitSecretAccessKey="[provided Secret Access Key]" \ --set secrets.pipekitClusterId="[provided Cluster ID]" \ --set configMap.allowExternalWorkflows=true ``` You can additionally set `configMap.shouldDeleteExternalWorkflows`. Refer to the values table above for more information. ## Pipekit Agent Cluster Permissions The Pipekit Agent needs to interact with Argo Workflows on your cluster. In order to do this, we create a ServiceAccount and ClusterRole for the Pipekit Agent. If you wish to manually manage this ServiceAccount and ClusterRole, you can set `serviceAccount.create` to false and provide the name of an existing ServiceAccount to use. The required minimum permissions are: ```yaml - apiGroups: - argoproj.io resources: - clusterworkflowtemplates - workflows - cronworkflows - workflowtemplates verbs: - create - delete - get - list - patch - update - watch ``` ## Upgrading Pipekit Agent ### Checking the latest version Pipekit Agent is automatically published to [Artifact Hub](https://artifacthub.io/packages/helm/pipekit-helm/pipekit-agent). You can use this service to configure automatic notifications of new versions, either via an RSS feed or a webhook. Alternatively, you can search the helm repo for the latest version of the Pipekit Agent using the following command: ```bash # Add the repo if you don't already have it. helm repo add pipekit https://helm.pipekit.io helm repo update helm search repo pipekit/pipekit-agent --versions ``` For further information on the `helm search repo` command, please refer to the [official Helm documentation](https://helm.sh/docs/helm/helm_search_repo/). ### Changes to the default values.yaml Prior to upgrading, you should ensure that you understand any changes to the default values.yaml and the impact those changes may have on your installation. This page is always updated with the latest available helm chart values for the Pipekit Agent. If you wish to upgrade to an older version of the Pipekit Agent helm chart, you can extract the default values for that version using the following command: ```bash helm show values pipekit/pipekit-agent --version [version] ``` The Pipekit-Agent values file is commented so you can see what each value does. You can extract your existing values from your current installation using the following command: ```bash helm get values pipekit-agent -n argo ``` For further information the helm commands used above, please refer to the [official Helm documentation](https://helm.sh/docs/helm/). ### Upgrading the Pipekit Agent To upgrade the Pipekit Agent, you can use the following command: ```bash helm upgrade pipekit-agent pipekit/pipekit-agent \ --set secrets.pipekitSecretAccessKey="[provided Secret Access Key]" \ --set secrets.pipekitClusterId="[provided Cluster ID]" \ -n argo ``` For more information on using Helm to perform upgrades, please check [the official Helm documentation](https://helm.sh/docs/helm/helm_upgrade/). ### Automating the upgrades using Gitops If you use a Gitops tool such as Argo CD, you can simply commit your changes to your git repository and the tool will handle the Helm upgrade for you. If you wish to automate the upgrade process, we recommend a third party tool called [Renovate Bot](https://docs.renovatebot.com/) that can be configured to automatically raise pull requests for you when a new version of the Pipekit Agent is released. ### Upgrade Support If you have an issue upgrading your Pipekit Agent that isn't addressed here, please contact us over Slack, or by email at . # Self-Hosted Chart Helm values for the self-hosted Pipekit chart. The Self-Hosted Pipekit Helm chart (`pipekit/pipekit`) installs the entire stack (UI, API, ID service, Postgres, Pipekit Agent) into a single Kubernetes namespace. This page links to the canonical values reference and covers the most commonly tuned values. For the install procedure, see [Self-Hosting > Deploy > Helm Install](/self-hosting-pipekit/dependencies/helm-install). For a 30-minute trial install on a local cluster, see [Self-Hosting > Evaluate Self-Hosted](/self-hosting-pipekit/evaluate). ## Discovering values The Pipekit values file is commented in-place. Every value's purpose is documented next to it. To dump the values for the version you have installed: ```bash helm show values pipekit/pipekit --version ``` For your current install's values: ```bash helm get values pipekit -n pipekit ``` ## Required values | Value | Type | Purpose | | ------------------------- | --------- | --------------------------------------------------------------------------------------------- | | `license.key` | string | Your Pipekit license key. Required for any non-`dev` install. | | `global.deployType` | enum | `dev` for local evaluation; `ci` for CI; `prod` for production. Controls resource defaults. | | `imagePullSecrets[].name` | string\[] | Name of the `regcred` Secret with credentials for the `pipekitprivate` Docker Hub repository. | ## Common production tunings | Value | Purpose | | ------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------- | | `.replicas` | Replica count per service. Defaults are sized for `dev`; bump for `prod`. | | `.resources.requests` | CPU and memory requests per service. The `dev` defaults are small; production deployments typically scale these 4-10x. | | `.hpa.enabled` | Enable the Horizontal Pod Autoscaler for a service. | | `.hpa.{min,max}Replicas` | HPA replica bounds. | | `.pdb.enabled` | Enable a Pod Disruption Budget. Strongly recommended for `prod`. | | `gitProviders.{github,gitlab,bitbucket,azureDevOps}.enabled` | Enable a Git provider. See [Configure > Git Provider](/self-hosting-pipekit/initial-login/git-provider). | | `gatewayAPI.enabled` | Use Gateway API resources instead of Ingress. Pair with `gatewayAPI.httpRoute`. | | `postgres.external.enabled` | Point Pipekit at a managed Postgres instead of the in-cluster bundled instance. Required for production HA. | ## Where each service's values live Each Pipekit service has its own block in the chart's `values.yaml`. The blocks all follow the same shape: image, resources, replicas, hpa, pdb, livenessProbe, readinessProbe. | Service | Block prefix | Notes | | ---------------- | ------------------- | ----------------------------------------------------------------------------------------------------- | | UI | `ui.*` | Web app; usually behind an ingress or Gateway HTTPRoute. | | Users API | `users.*` | Main API for Pipes/Runs/Workflows. | | ID | `id.*` | Authn (SSO, MFA, user creation). | | Events Handler | `eventsHandler.*` | Webhook receiver for Git providers; only enabled if you wire up GitHub/GitLab/Bitbucket/Azure DevOps. | | Messenger | `messenger.*` | Redis-backed queue + log broker between Users and Pipekit Agent. | | Notifications | `notifications.*` | Email / Slack / Teams alert dispatch. | | Pipekit Agent | `pipekitAgent.*` | In-cluster component. Often configured separately via the agent's own Helm chart. | | Metrics Operator | `metricsOperator.*` | OTel-based workflow metrics. Optional. | | Postgres | `postgres.*` | Embedded for dev; external for prod. | For the full annotated reference, see [Self-Hosting > Deploy > Helm Install](/self-hosting-pipekit/dependencies/helm-install#changes-to-the-default-valuesyaml), which embeds the chart's `values.yaml` with every parameter documented inline. ## Related * [Agent Chart Values](/reference/helm-values/agent): values reference for the `pipekit-agent` chart used in BYOC / Pipekit Cloud deployments. * [Self-Hosting > Configure](/self-hosting-pipekit/initial-login): post-install configuration (initial login, SSO, Git providers, agent options).