ScyllaDB Operator automates the deployment and management of ScyllaDB clusters on Kubernetes.
It handles provisioning, scaling, upgrades, repairs, backups, and monitoring — so you can focus on your application instead of database operations.
# index.md
# Reference
Specifications, support matrices, and lookup tables for ScyllaDB Operator.
* [API Reference](https://operator.docs.scylladb.com/stable/reference/api/index.md)
* [Feature gates](https://operator.docs.scylladb.com/stable/reference/feature-gates.md)
* [IPv6 configuration reference](https://operator.docs.scylladb.com/stable/reference/ipv6-configuration.md)
* [Releases](https://operator.docs.scylladb.com/stable/reference/releases.md)
* [Known issues](https://operator.docs.scylladb.com/stable/reference/known-issues.md)
* [Conditions reference](https://operator.docs.scylladb.com/stable/reference/conditions.md)
* [nodetool alternatives](https://operator.docs.scylladb.com/stable/reference/nodetool-alternatives.md)
# index.md
# Contributing to ScyllaDB Operator
ScyllaDB Operator is an open-source project. Contributions of all kinds are welcome — bug reports, documentation improvements, feature requests, and code.
## Getting started
Before contributing, read the [CONTRIBUTING.md](https://github.com/scylladb/scylla-operator/blob/master/CONTRIBUTING.md) file in the repository root.
It covers:
- Setting up the development environment (Go, `kind`, and required tools).
- Building the Operator binary and image.
- Running the end-to-end and unit test suites.
- The contribution workflow (fork → branch → PR).
- Coding conventions and commit message guidelines.
## Quick start
Clone the repository and build the Operator:
```bash
git clone https://github.com/scylladb/scylla-operator.git
cd scylla-operator
make build
```
Run unit tests:
```bash
make test
```
Run the linter:
```bash
make lint
```
Deploy to a local `kind` cluster for development:
```bash
make deploy
```
## Deploying a custom build
To build and push a custom Operator image to your own registry:
```bash
IMAGE=/scylla-operator: make build-image
IMAGE=/scylla-operator: make push-image
```
Then update the Operator deployment to use your image:
```bash
kubectl -n scylla-operator set image deployment/scylla-operator \
scylla-operator=/scylla-operator:
```
#### WARNING
Custom builds are intended for development and testing only.
ScyllaDB Support does not cover clusters running custom Operator images.
## Reporting issues
Report issues on the [GitHub issue tracker](https://github.com/scylladb/scylla-operator/issues).
Before opening a new issue:
1. Search existing issues to avoid duplicates.
2. Include the Operator version (`kubectl -n scylla-operator get deployment scylla-operator -o jsonpath='{.spec.template.spec.containers[0].image}'`).
3. Attach a [debugging information archive](https://operator.docs.scylladb.com/stable/troubleshoot/collect-debugging-information/index.md) if the issue is a runtime problem.
## Related pages
- [CONTRIBUTING.md](https://github.com/scylladb/scylla-operator/blob/master/CONTRIBUTING.md) — full contributor guide
- [GitHub repository](https://github.com/scylladb/scylla-operator)
# index.md
# Understand
ScyllaDB Operator is a set of controllers and API extensions that run inside your Kubernetes cluster.
It extends the Kubernetes API using [CustomResourceDefinitions (CRDs)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/) and [dynamic admission webhooks](https://kubernetes.io/docs/reference/access-authn-authz/extensible-admission-controllers/) to provide new resources.
These resources are reconciled by controllers embedded within the ScyllaDB Operator deployment.
## Reconciliation model
ScyllaDB Operator follows the standard Kubernetes [controller pattern](https://kubernetes.io/docs/concepts/architecture/controller/).
Each controller watches one or more resource types and continuously reconciles the desired state (what you declared in the custom resource spec) with the actual state (what currently exists in the cluster).
A reconciliation loop runs whenever a watched resource changes, or periodically on a 12-hour resync interval.
During each reconciliation, the controller:
1. Reads the current spec of the custom resource.
2. Computes the set of Kubernetes objects that should exist (StatefulSets, Services, ConfigMaps, Jobs, PodDisruptionBudgets, and more).
3. Creates, updates, or deletes objects to match the desired state.
4. Updates the custom resource’s status to reflect the current state.
This means that manual changes to managed objects (such as editing a StatefulSet created by the Operator) will be reverted on the next reconciliation.
To make changes, always modify the custom resource spec.
## Deployments and namespaces
ScyllaDB Operator installs into three namespaces:
| Namespace | What runs there |
|-------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `scylla-operator` | Two Deployments: the **controller manager** (`scylla-operator`) that runs all controllers, and the **webhook server** (`webhook-server`) that validates API requests. Both run with 2 replicas by default and are protected by PodDisruptionBudgets. |
| `scylla-manager` | **ScyllaDB Manager** — a separate component that coordinates repair and backup tasks. It uses a small internal ScyllaDB cluster as its own database. Deployed optionally. |
| `scylla-operator-node-tuning` | **Node tuning agents** — privileged DaemonSets and Jobs created by the NodeConfig controller to set up disks, filesystems, and performance tuning on Kubernetes nodes. |
Your ScyllaDB clusters run in your own namespaces, separate from the Operator.
## Custom resources
The Operator provides the following CRDs, all in the `scylla.scylladb.com` API group:
### Cluster-scoped resources
Cluster-scoped resources affect the entire Kubernetes cluster and require elevated privileges.
| Resource | API version | Purpose |
|------------------------|---------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `NodeConfig` | `v1alpha1` | Configures Kubernetes nodes for ScyllaDB: RAID setup, filesystem creation, mount points, sysctls, and performance tuning. See [Tuning](https://operator.docs.scylladb.com/stable/understand/tuning.md). |
| `ScyllaOperatorConfig` | `v1alpha1` | Global Operator configuration: auxiliary images, cluster domain, tuning image overrides. A singleton named `cluster`. |
### Namespaced resources
Namespaced resources are scoped to a Kubernetes namespace and can be managed by namespace-level RBAC.
| Resource | API version | Purpose |
|-----------------------|---------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `ScyllaCluster` | `v1` (stable) | Defines a single-datacenter ScyllaDB cluster. The primary resource for most deployments. |
| `ScyllaDBMonitoring` | `v1alpha1` | Defines a monitoring stack (Prometheus + Grafana) for ScyllaDB. See [Set up monitoring](https://operator.docs.scylladb.com/stable/understand/monitoring.md). |
| `ScyllaDBManagerTask` | `v1alpha1` | Defines a backup or repair task managed by ScyllaDB Manager. |
## Controllers
The controller manager runs the following controllers:
| Controller | What it reconciles |
|------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| ScyllaCluster | Primary controller for single-datacenter deployments. Manages a ScyllaDB datacenter — StatefulSets, Services, ConfigMaps, Jobs, PDBs, Ingresses, TLS certificates — and synchronises Manager tasks based on the stable `ScyllaCluster` (v1) API. |
| ScyllaDBDatacenter | Internal controller that creates and manages the underlying Kubernetes objects for each datacenter. Users do not interact with `ScyllaDBDatacenter` resources directly — the ScyllaCluster controller translates each `ScyllaCluster` into an internal `ScyllaDBDatacenter` resource, which this controller then reconciles. |
| NodeConfig | Deploys privileged DaemonSets and Jobs that set up RAID, filesystems, mount points, sysctls, and performance tuning on Kubernetes nodes. |
| NodeConfigPod | Watches ScyllaDB pods and creates per-pod tuning ConfigMaps that tie container-level tuning to a specific container instance. |
| ScyllaOperatorConfig | Reconciles the global Operator configuration, discovers cluster domain, and resolves auxiliary images. |
| ScyllaDBMonitoring | Deploys and configures Prometheus, Grafana, ServiceMonitors, PrometheusRules, and dashboards. |
| OrphanedPV | Detects and cleans up PersistentVolumes that become orphaned when ScyllaDB nodes are removed. |
| ScyllaDBManager | Coordinates global ScyllaDB Manager state across all clusters. |
| ScyllaDBManagerClusterRegistration | Registers ScyllaDB clusters with ScyllaDB Manager. |
| ScyllaDBManagerTask | Reconciles backup and repair task definitions with ScyllaDB Manager. |
### Experimental controllers
The following controllers are run by Operator, but there is no current plan to make their respective CRDs generally available. These controllers and CRDs may be removed in a future version.
| Controller | What it reconciles |
|-------------------------|----------------------------------------------------------------------------------------------------------------------|
| ScyllaDBCluster | Orchestrates multi-datacenter clusters by managing `ScyllaDBDatacenter` resources across remote Kubernetes clusters. |
| RemoteKubernetesCluster | Manages connections and informers for remote Kubernetes clusters used in multi-DC deployments. |
Additional controllers run **inside ScyllaDB pods** rather than in the Operator deployment:
| Controller | Where it runs | What it does |
|------------------|---------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Sidecar | Main ScyllaDB container | Manages the ScyllaDB process lifecycle, syncs member service annotations with host ID and token ring state. See [Sidecar](https://operator.docs.scylladb.com/stable/understand/sidecar.md). |
| Ignition | `scylladb-ignition` sidecar container | Evaluates startup prerequisites (tuning done, IP assigned, LB ready) and creates the ignition signal file. See [Ignition](https://operator.docs.scylladb.com/stable/understand/ignition.md). |
| StatusReport | Main ScyllaDB container | Reports node status to internal status report resources for bootstrap synchronisation. |
| BootstrapBarrier | `scylladb-bootstrap-barrier` init container | Blocks pod startup until bootstrap preconditions are met (feature-gated). See [Bootstrap Sync](https://operator.docs.scylladb.com/stable/understand/bootstrap-sync.md). |
| NodeSetup | Node tuning DaemonSet pods | Configures the host machine (runs via the `node-setup-daemon` subcommand). |
## Admission webhooks
The Operator runs a webhook server that validates **create** and **update** operations on all public CRDs.
The webhook server runs as a separate Deployment (`scylla-operator-webhook-server`) in the `scylla-operator` namespace and is exposed via a Service on port 443.
TLS certificates for the webhook server are provisioned automatically using [cert-manager](https://cert-manager.io/).
The `ValidatingWebhookConfiguration` is configured with a `caBundle` injected by cert-manager.
# index.md
# Get Started
New to ScyllaDB Operator? Start here to understand what the Operator does and how Kubernetes concepts map to ScyllaDB.
When you are ready to install, proceed to [Install Operator](https://operator.docs.scylladb.com/stable/install-operator/index.md). To deploy a ScyllaDB cluster, see [Deploy ScyllaDB](https://operator.docs.scylladb.com/stable/deploy-scylladb/index.md).
* [What Is ScyllaDB Operator?](https://operator.docs.scylladb.com/stable/get-started/what-is-scylladb-operator.md)
* [ScyllaDB Concepts on Kubernetes](https://operator.docs.scylladb.com/stable/get-started/concepts-for-k8s-beginners.md)
# index.md
# Deploy ScyllaDB
This section covers deploying and configuring ScyllaDB clusters on Kubernetes.
## Deployment paths
### Supported platform (production)
If you are running on a [supported platform](https://operator.docs.scylladb.com/stable/reference/releases.md#supported-kubernetes-environments), follow a [reference deployment](https://operator.docs.scylladb.com/stable/deploy-scylladb/reference-deployments/index.md).
Reference deployments are end-to-end guides that walk you through node preparation, operator configuration, and deploying a production-ready ScyllaDB cluster.
The reference deployment guides link to [Before you deploy](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/index.md) for node preparation steps — you do not need to follow those pages separately.
### Generic or development cluster
If you want a quick development cluster on any Kubernetes distribution, use [Deploy your first cluster](https://operator.docs.scylladb.com/stable/deploy-scylladb/deploy-your-first-cluster.md).
This guide deploys a minimal ScyllaDB cluster and is not intended for production use.
For production, complete the [Before you deploy](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/index.md) steps first.
### Multi-datacenter cluster
To span a ScyllaDB cluster across several datacenters, follow [Deploy a multi-datacenter ScyllaDB cluster](https://operator.docs.scylladb.com/stable/deploy-scylladb/deploy-multi-datacenter-cluster.md).
This requires multiple interconnected Kubernetes clusters — see [Provision infrastructure](https://operator.docs.scylladb.com/stable/install-operator/provision-infrastructure/index.md) for guides on preparing them.
## Further configuration
After your cluster is running, see these guides for additional setup:
- [Set up networking](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/index.md) — expose ScyllaDB outside the Kubernetes cluster.
- [Install ScyllaDB Manager](https://operator.docs.scylladb.com/stable/deploy-scylladb/install-scylladb-manager.md) — enable automated backups, repairs, and restore.
- [Set up monitoring](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-monitoring/index.md) — integrate with Prometheus and Grafana.
- [Production checklist](https://operator.docs.scylladb.com/stable/deploy-scylladb/production-checklist.md) — verify your deployment is production-ready.
# index.md
# Install Operator
Install ScyllaDB Operator and its dependencies into your Kubernetes cluster.
Before installing, review [Provision infrastructure](https://operator.docs.scylladb.com/stable/install-operator/provision-infrastructure/index.md) to ensure your environment meets all requirements.
## Software prerequisites
### cert-manager
ScyllaDB Operator uses [cert-manager](https://cert-manager.io/) to manage TLS certificates for webhook servers.
cert-manager must be installed before the operator.
See [Install with GitOps](https://operator.docs.scylladb.com/stable/install-operator/install-with-gitops.md) for installation steps.
### Prometheus Operator (optional)
If you plan to use ScyllaDB Operator’s [monitoring integration](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-monitoring/index.md), the [Prometheus Operator](https://github.com/prometheus-operator/prometheus-operator) must be installed in the cluster.
This is not required for the operator itself to function.
## Installation methods
Choose the installation method that matches your environment:
- **[GitOps](https://operator.docs.scylladb.com/stable/install-operator/install-with-gitops.md)** — install using `kubectl apply` with manifests from the project repository. Recommended for most environments.
- **[Helm](https://operator.docs.scylladb.com/stable/install-operator/install-with-helm.md)** — install using Helm charts.
- **[OpenShift](https://operator.docs.scylladb.com/stable/install-operator/install-on-openshift.md)** — install via the Operator Lifecycle Manager (OLM) software catalog on Red Hat OpenShift.
# index.md
# Connect Your App
This section covers how to connect applications and tools to a ScyllaDB cluster running on Kubernetes.
* [Connect via CQL](https://operator.docs.scylladb.com/stable/connect-your-app/connect-via-cql.md)
* [Alternator (DynamoDB API)](https://operator.docs.scylladb.com/stable/connect-your-app/alternator.md)
* [Discovery endpoint](https://operator.docs.scylladb.com/stable/connect-your-app/discovery.md)
# index.md
# Upgrade
Guides for upgrading ScyllaDB Operator and ScyllaDB.
* [Upgrading ScyllaDB Operator](https://operator.docs.scylladb.com/stable/upgrade/upgrade-operator.md)
* [Upgrading ScyllaDB clusters](https://operator.docs.scylladb.com/stable/upgrade/upgrade-scylladb.md)
# index.md
# Operate
Day-two operations — scaling, backup, and maintenance tasks for running clusters.
* [Scale, add, remove racks](https://operator.docs.scylladb.com/stable/operate/scale-add-remove-racks.md)
* [Replace nodes](https://operator.docs.scylladb.com/stable/operate/replace-nodes.md)
* [Expand storage volumes](https://operator.docs.scylladb.com/stable/operate/expand-storage-volumes.md)
* [Use maintenance mode](https://operator.docs.scylladb.com/stable/operate/use-maintenance-mode.md)
* [Back up and restore](https://operator.docs.scylladb.com/stable/operate/back-up-and-restore.md)
* [Restore from backup](https://operator.docs.scylladb.com/stable/operate/restore-from-backup.md)
* [Perform a rolling restart](https://operator.docs.scylladb.com/stable/operate/perform-rolling-restart.md)
* [Migrate a rack to a new node pool](https://operator.docs.scylladb.com/stable/operate/migrate-rack-to-new-node-pool.md)
* [Pass additional ScyllaDB arguments](https://operator.docs.scylladb.com/stable/operate/pass-scylladb-arguments.md)
* [Configure precomputed IO properties](https://operator.docs.scylladb.com/stable/operate/configure-io-properties.md)
# index.md
# Troubleshoot
Diagnose and resolve issues with ScyllaDB Operator, ScyllaDB clusters, and related infrastructure.
## By symptom
| Symptom | Guide |
|------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Pods restarting unexpectedly | [Investigate pod restarts](https://operator.docs.scylladb.com/stable/troubleshoot/investigate-restarts.md) |
| Application cannot connect to ScyllaDB | [Connect Your App](https://operator.docs.scylladb.com/stable/connect-your-app/index.md) and [Set up networking](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/index.md) |
| Upgrade failed or stuck | [Upgrade](https://operator.docs.scylladb.com/stable/upgrade/index.md) |
| Node replace stuck or failed | [Recover from a failed node replace](https://operator.docs.scylladb.com/stable/troubleshoot/recover-from-failed-replace.md) |
| Slow queries, throughput degradation, or CPU pinning not working | [Troubleshoot performance](https://operator.docs.scylladb.com/stable/troubleshoot/troubleshoot-performance.md) |
| Need to change log level without a rolling restart | [Change log level](https://operator.docs.scylladb.com/stable/troubleshoot/change-log-level.md) |
| Need to collect data for a support ticket | [Collect debugging information](https://operator.docs.scylladb.com/stable/troubleshoot/collect-debugging-information/index.md) |
| Need to configure or collect core dumps | [Collect core dumps](https://operator.docs.scylladb.com/stable/troubleshoot/configure-coredumps.md) |
* [Investigate pod restarts](https://operator.docs.scylladb.com/stable/troubleshoot/investigate-restarts.md)
* [Change log level on a live cluster](https://operator.docs.scylladb.com/stable/troubleshoot/change-log-level.md)
* [Recover from a failed node replace](https://operator.docs.scylladb.com/stable/troubleshoot/recover-from-failed-replace.md)
* [Troubleshoot performance](https://operator.docs.scylladb.com/stable/troubleshoot/troubleshoot-performance.md)
* [Collect debugging information](https://operator.docs.scylladb.com/stable/troubleshoot/collect-debugging-information/index.md)
* [Collect core dumps](https://operator.docs.scylladb.com/stable/troubleshoot/configure-coredumps.md)
# index.md
# API Reference
All APIs provided by Scylla Operator are defined using CRDs and adhere to Kubernetes API standards. You can find out how Kubernetes style REST APIs work on [https://kubernetes.io/docs/reference/using-api/](https://kubernetes.io/docs/reference/using-api/) and [https://kubernetes.io/docs/reference/access-authn-authz/](https://kubernetes.io/docs/reference/access-authn-authz/).
## API Groups and Kinds
* [scylla.scylladb.com](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com.md)
* [NodeConfig (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/nodeconfigs.md)
* [RemoteKubernetesCluster (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/remotekubernetesclusters.md)
* [RemoteOwner (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/remoteowners.md)
* [ScyllaCluster (scylla.scylladb.com/v1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/scyllaclusters.md)
* [ScyllaDBCluster (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/scylladbclusters.md)
* [ScyllaDBDatacenterNodesStatusReport (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/scylladbdatacenternodesstatusreports.md)
* [ScyllaDBDatacenter (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/scylladbdatacenters.md)
* [ScyllaDBManagerClusterRegistration (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/scylladbmanagerclusterregistrations.md)
* [ScyllaDBManagerTask (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/scylladbmanagertasks.md)
* [ScyllaDBMonitoring (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/scylladbmonitorings.md)
* [ScyllaOperatorConfig (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/scyllaoperatorconfigs.md)
# index.md
# Before you deploy
Before deploying a ScyllaDB cluster, prepare your Kubernetes nodes and operator configuration.
These steps ensure ScyllaDB runs with optimal performance and isolation.
#### NOTE
If you are following a [reference deployment](https://operator.docs.scylladb.com/stable/deploy-scylladb/reference-deployments/index.md), it links to these pages at the appropriate steps — you do not need to follow them separately.
## Node preparation
ScyllaDB needs dedicated nodes with local NVMe storage, CPU pinning, and node tuning.
Complete these steps in order:
1. [Set up dedicated node pools](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/set-up-dedicated-node-pools.md) — provision and label nodes, apply taints.
2. [Configure CPU pinning](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/configure-cpu-pinning.md) — enable the static CPU manager policy.
3. [Configure nodes](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/configure-nodes.md) — apply `NodeConfig` for disk setup and kernel tuning.
## Operator configuration
- [Configure the Operator](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/configure-operator.md) — tune operator-level settings.
# index.md
# Set up networking
Configure how ScyllaDB clusters are exposed inside and outside Kubernetes, including IPv6 support.
* [Configure external access](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/configure-external-access.md)
* [IPv6 networking](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/index.md)
# index.md
# Set up monitoring
ScyllaDB Operator provides the `ScyllaDBMonitoring` custom resource to set up a complete monitoring stack for your ScyllaDB clusters, based on Prometheus for metrics collection and Grafana for visualization.
For details on the monitoring architecture, Prometheus modes (External and Managed), and how the components fit together, see [Monitoring](https://operator.docs.scylladb.com/stable/understand/monitoring.md).
## Guides
- [Set up ScyllaDB Monitoring](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-monitoring/setup.md) — deploy Prometheus and configure `ScyllaDBMonitoring` for your cluster.
- [Set up ScyllaDB Monitoring on OpenShift](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-monitoring/external-prometheus-on-openshift.md) — use OpenShift User Workload Monitoring as an external Prometheus source.
- [Expose Grafana](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-monitoring/exposing-grafana.md) — make the Grafana dashboard accessible outside the cluster.
# index.md
# Reference deployments
End-to-end guides that cover the complete setup from scratch on a specific platform — from infrastructure provisioning through a running ScyllaDB cluster.
- [GKE](https://operator.docs.scylladb.com/stable/deploy-scylladb/reference-deployments/reference-deployment-gke.md) — Google Kubernetes Engine.
- [EKS](https://operator.docs.scylladb.com/stable/deploy-scylladb/reference-deployments/reference-deployment-eks.md) — Amazon EKS.
- [OKE](https://operator.docs.scylladb.com/stable/deploy-scylladb/reference-deployments/reference-deployment-oke.md) — Oracle Container Engine for Kubernetes.
- [OpenShift](https://operator.docs.scylladb.com/stable/deploy-scylladb/reference-deployments/reference-deployment-openshift.md) — Red Hat OpenShift.
# index.md
# IPv6 networking
IPv6 networking support enables you to run ScyllaDB clusters on IPv6 networks, with options for IPv6-only, IPv4-only, or dual-stack (both protocols) configurations.
#### NOTE
IPv6-only configurations are experimental. All other configurations are production-ready. See [Production readiness](https://operator.docs.scylladb.com/stable/reference/ipv6-configuration.md#production-readiness) for details.
## Tutorials
Start here if you’re new to IPv6 networking in ScyllaDB:
- [Getting started with IPv6 networking](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/get-started.md) - Your first IPv6-enabled cluster with step-by-step guidance
## How-to guides
Practical guides for specific tasks:
- [Configure dual-stack networking](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/configure-dual-stack.md) - IPv4-first (recommended) and IPv6-first dual-stack
- [Configure IPv6-only](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/configure-single-stack.md) - IPv6 single-stack (experimental)
- [Migrate clusters to IPv6](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/migration.md) - Migrate existing clusters from IPv4 to IPv6
- [Troubleshoot IPv6 networking issues](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/troubleshooting.md) - Diagnose and resolve common problems
## Reference
Technical specifications and API details:
- [IPv6 configuration reference](https://operator.docs.scylladb.com/stable/reference/ipv6-configuration.md) - Complete API reference for IPv6 settings
## Concepts
Deep explanations of how IPv6 networking works:
- [IPv6 networking concepts](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/ipv6-concepts.md) - Understand how IPv6 support works in ScyllaDB
## Configuration examples
Quick examples for common scenarios:
**Dual-stack (recommended for production)**:
```yaml
network:
ipFamilyPolicy: PreferDualStack
ipFamilies:
- IPv4 # ScyllaDB uses IPv4
- IPv6 # Services also support IPv6
dnsPolicy: ClusterFirst
```
**IPv6-only (experimental)**:
```yaml
network:
ipFamilyPolicy: SingleStack
ipFamilies:
- IPv6
dnsPolicy: ClusterFirst
```
**IPv4-only (default)**:
```yaml
network:
ipFamilyPolicy: SingleStack
ipFamilies:
- IPv4
```
For complete examples, see the [how-to guides](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/configure-dual-stack.md).
## Key concepts
### IP family selection
The **first** IP family in `network.ipFamilies` determines which protocol ScyllaDB uses internally:
- `[IPv6]` → ScyllaDB uses IPv6
- `[IPv4, IPv6]` → ScyllaDB uses IPv4, services support both
- `[IPv6, IPv4]` → ScyllaDB uses IPv6, services support both
Learn more in [IPv6 networking concepts](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/ipv6-concepts.md).
### Dual-stack behavior
“Dual-stack” refers to Kubernetes services having both IPv4 and IPv6 addresses. ScyllaDB itself always runs on a single IP family (the first one configured).
This provides client flexibility while maintaining internal consistency.
### DNS configuration
For IPv6, `dnsPolicy: ClusterFirst` is essential to ensure proper DNS resolution of IPv6 addresses.
## Prerequisites
Before configuring IPv6:
- **Network**: Cluster must have IPv6 networking configured
## Feature status
| Configuration | Status | Production Ready |
|--------------------------|--------------|--------------------|
| Dual-stack (IPv4 + IPv6) | Stable | Yes |
| IPv6-only | Experimental | No |
| IPv4-only | Stable | Yes |
For IPv6-only production support progress, see [#3211](https://github.com/scylladb/scylla-operator/issues/3211).
## Getting help
If you need assistance:
1. **Check documentation**: Review the troubleshooting guide and concepts
2. **Search issues**: Look for similar problems in [GitHub issues](https://github.com/scylladb/scylla-operator/issues)
3. **Ask the community**: Join [ScyllaDB Slack](https://slack.scylladb.com/)
4. **Open an issue**: Report bugs or request features on [GitHub](https://github.com/scylladb/scylla-operator/issues/new)
## Related documentation
- [Networking overview](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/index.md)
- [Kubernetes IPv6 Documentation](https://kubernetes.io/docs/concepts/services-networking/dual-stack/)
# index.md
# Provision infrastructure
Before installing ScyllaDB Operator, ensure your environment meets the following requirements.
## Kubernetes cluster
ScyllaDB Operator requires a [supported Kubernetes environment](https://operator.docs.scylladb.com/stable/reference/releases.md).
Issues on unsupported environments are unlikely to be addressed.
If you do not have a cluster yet, follow one of the platform-specific guides:
- [Set up a GKE cluster](https://operator.docs.scylladb.com/stable/install-operator/provision-infrastructure/set-up-gke-cluster.md) — Google Kubernetes Engine.
- [Set up an EKS cluster](https://operator.docs.scylladb.com/stable/install-operator/provision-infrastructure/set-up-eks-cluster.md) — Amazon Elastic Kubernetes Service.
- [Set up an OKE cluster](https://operator.docs.scylladb.com/stable/install-operator/provision-infrastructure/set-up-oke-cluster.md) — Oracle Container Engine for Kubernetes.
- [Set up an OpenShift cluster](https://operator.docs.scylladb.com/stable/install-operator/provision-infrastructure/set-up-openshift-cluster.md) — Red Hat OpenShift.
For a multi-datacenter ScyllaDB cluster, you need several interconnected Kubernetes clusters — see [Multi-DC](https://operator.docs.scylladb.com/stable/install-operator/provision-infrastructure/multi-dc/index.md).
# index.md
# Multi-DC
A multi-datacenter ScyllaDB cluster runs each datacenter in a separate Kubernetes cluster.
The Kubernetes clusters have to be able to reach each other over Pod IPs, which requires additional networking setup beyond a single-cluster deployment.
Follow the guide for your platform:
- [Set up multiple GKE clusters](https://operator.docs.scylladb.com/stable/install-operator/provision-infrastructure/multi-dc/set-up-multi-dc-gke-clusters.md) — GKE clusters in a shared VPC, with inter-Kubernetes networking.
- [Set up multiple EKS clusters](https://operator.docs.scylladb.com/stable/install-operator/provision-infrastructure/multi-dc/set-up-multi-dc-eks-clusters.md) — EKS clusters in peered VPCs, with inter-Kubernetes networking.
Once the platform is ready, follow [Deploy a multi-datacenter ScyllaDB cluster](https://operator.docs.scylladb.com/stable/deploy-scylladb/deploy-multi-datacenter-cluster.md).
# index.md
# Collect debugging information
Methods for gathering diagnostic data when troubleshooting ScyllaDB Operator issues or filing support tickets.
* [Collect data with must-gather](https://operator.docs.scylladb.com/stable/troubleshoot/collect-debugging-information/must-gather.md)
* [must-gather contents](https://operator.docs.scylladb.com/stable/troubleshoot/collect-debugging-information/must-gather-contents.md)
* [Query system tables for debugging](https://operator.docs.scylladb.com/stable/troubleshoot/collect-debugging-information/system-tables.md)
# alternator.md
# Alternator (DynamoDB API)
This page explains how to enable and use ScyllaDB’s Alternator, a DynamoDB-compatible API, on Kubernetes.
## Enable Alternator
Add the `alternator` section to your ScyllaCluster spec:
```yaml
apiVersion: scylla.scylladb.com/v1
kind: ScyllaCluster
metadata:
name: scylladb
spec:
alternator: {}
# ... rest of the spec
```
This enables the Alternator API with HTTPS on port `8043` and authorization enabled by default.
### Configuration options
| Field | Description | Default |
|--------------------------------|---------------------------------------------------------------------|-------------------------|
| `writeIsolation` | Write isolation level for Alternator operations. | `""` (ScyllaDB default) |
| `insecureEnableHTTP` | Also serve Alternator on the unencrypted HTTP port. | `false` |
| `insecureDisableAuthorization` | Disable Alternator authorization. | `false` |
| `servingCertificate.type` | TLS certificate configuration (`OperatorManaged` or `UserManaged`). | `OperatorManaged` |
#### NOTE
Unlike CQL clients, Alternator clients do not need to connect to every ScyllaDB node directly or discover individual node IP addresses. The Alternator protocol is HTTP-based, so you can also expose it through an Ingress or other HTTP networking concepts.
## Obtain credentials
Alternator uses the CQL `salted_hash` from `system.roles` as the AWS secret access key. The access key ID is the CQL username.
```shell
CLUSTER_NAME=scylladb
CQL_USER=cassandra
kubectl exec -it service/${CLUSTER_NAME}-client -c scylla -- cqlsh --user ${CQL_USER} \
-e "SELECT salted_hash FROM system.roles WHERE role = '${CQL_USER}'"
```
## Connect with AWS CLI
Set up the environment variables and TLS CA bundle:
**Step 1: Look up the Alternator endpoint**
```shell
CLUSTER_NAME=scylladb
CQL_USER=cassandra
SCYLLADB_EP="$(kubectl get service/${CLUSTER_NAME}-client -o='jsonpath={.spec.clusterIP}')"
export AWS_ENDPOINT_URL_DYNAMODB="https://${SCYLLADB_EP}:8043"
```
**Step 2: Set the access key ID**
```shell
export AWS_ACCESS_KEY_ID="${CQL_USER}"
```
**Step 3: Get the secret access key**
```shell
AWS_SECRET_ACCESS_KEY="$(kubectl exec -i service/${CLUSTER_NAME}-client -c scylla -- cqlsh --user ${CQL_USER} --no-color \
-e "SELECT salted_hash from system.roles WHERE role = '${AWS_ACCESS_KEY_ID}';" \
| sed -e 's/\r//g' | sed -e '4q;d' | sed -E -e 's/^\s+//')"
export AWS_SECRET_ACCESS_KEY
```
**Step 4: Download the TLS CA bundle**
```shell
AWS_CA_BUNDLE="$(mktemp)"
export AWS_CA_BUNDLE
kubectl get configmap/${CLUSTER_NAME}-alternator-local-serving-ca \
--template='{{ index .data "ca-bundle.crt" }}' > "${AWS_CA_BUNDLE}"
```
Now use the `aws dynamodb` CLI normally:
```shell
aws dynamodb create-table \
--table-name SeaMonsters \
--attribute-definitions AttributeName=Species,AttributeType=S AttributeName=MonsterName,AttributeType=S \
--key-schema AttributeName=Species,KeyType=HASH AttributeName=MonsterName,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5
```
```shell
aws dynamodb list-tables
```
```default
TABLENAMES SeaMonsters
```
## TLS certificate resources
The Operator creates these resources for Alternator:
| Resource | Name | Contents |
|------------|--------------------------------------------------------|----------------------------------------------------|
| Serving CA | `configmap/-alternator-local-serving-ca` | `ca-bundle.crt` — CA to validate Alternator HTTPS. |
### Troubleshoot
- **`AccessDeniedException`**: Confirms Alternator is reachable but credentials are wrong. Re-extract credentials per the steps above and verify they match.
- **`Could not connect to the endpoint`**: Alternator may not be enabled on the cluster. Verify `spec.alternator` is set in the ScyllaCluster and Pods are running. Check that the Service port (8043 for HTTPS by default) is reachable.
## Multi-datacenter limitations
When using Alternator with a multi-datacenter ScyllaDB deployment (multiple `ScyllaCluster` resources connected via `externalSeeds`), the following constraints apply:
| Limitation | Detail |
|------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| No built-in cross-DC routing | Alternator endpoints are per-datacenter. There is no built-in load balancer that routes DynamoDB API requests across datacenters. Connect your application to the Alternator endpoint in the datacenter closest to it. |
| Authentication tokens are DC-local | Each `ScyllaCluster` has its own Alternator authentication credentials. If you require the same credentials across DCs, you must configure the same `alternatorWriteIsolation` and authentication settings on each cluster independently. |
## Related pages
- [Connect via CQL](https://operator.docs.scylladb.com/stable/connect-your-app/connect-via-cql.md) — CQL connection and authentication setup.
- [Discovery endpoint](https://operator.docs.scylladb.com/stable/connect-your-app/discovery.md) — how the client Service works.
- [Security](https://operator.docs.scylladb.com/stable/understand/security.md) — TLS certificate management.
# automatic-data-cleanup.md
# Automatic data cleanup
This page explains why ScyllaDB Operator runs automatic data cleanup after scaling operations and how the mechanism works.
## Why cleanup is needed
When a ScyllaDB cluster scales horizontally (nodes are added or removed), the ownership of data tokens changes. Nodes that lose ownership of certain token ranges still hold the corresponding data on disk. This stale data must be removed to:
1. **Reclaim storage** — stale data wastes disk space unnecessarily.
2. **Prevent data resurrection** — if stale data is not removed, it can reappear during repair or read operations, overriding newer deletions.
ScyllaDB handles cleanup automatically for keyspaces that use tablets. However, system keyspaces and standard vnode-based keyspaces are not covered by this automatic mechanism. ScyllaDB Operator fills the gap by triggering cleanup on all keyspaces — the cleanup of tablet-based keyspaces is a no-op on the server side.
## Trigger mechanism
The Operator tracks the token ring of each ScyllaDB cluster. When the ring changes — because a node was added, removed, or replaced — the Operator compares the current ring state against the last state for which cleanup was completed. If they differ, cleanup Jobs are created for all nodes that were affected by the token redistribution.
Before creating any Jobs, the Operator waits for the cluster to reach a stable state:
- `StatefulSetControllerProgressing` is `False`.
- `Available` is `True`.
- `Degraded` is `False`.
This ensures that cleanup runs only after the scaling operation has fully completed and the cluster is healthy.
### What triggers cleanup
- **Scale-out** — after a new node finishes bootstrapping. Cleanup runs on the pre-existing nodes whose token ring hash changed. The newly added node is not cleaned up because its member Service is initialized with matching hashes.
- **Scale-in (decommission)** — after a node is removed. The remaining nodes inherit its tokens but technically do not need cleanup (they did not lose tokens). The Operator still triggers cleanup because the token ring changed. This is safe but may cause a brief I/O spike.
- **Initial cluster bootstrap** — when a node’s member Service is first created, the Operator initializes `last-cleaned-up-token-ring-hash` to the current token ring hash. Because the hashes start equal, no cleanup is triggered during initial bootstrap.
## Cleanup Job details
The Operator creates one Kubernetes `Job` per affected node. Each Job runs the `scylla-operator cleanup-job` subcommand, which connects to the ScyllaDB REST API on the target node through the Manager Agent proxy (port 10001) and runs cleanup on every keyspace. The Job pod authenticates using a Manager Agent auth token mounted from a Secret.
When a cleanup Job completes successfully, the Operator deletes it. If a Job is still running, the `ScyllaCluster` status shows the `JobControllerProgressing` condition set to `True` with a message listing the active Job names.
## Inspecting cleanup status
Check whether cleanup is in progress:
```bash
kubectl get scyllacluster -o jsonpath='{.status.conditions[?(@.type=="JobControllerProgressing")]}' | jq
```
When no cleanup Jobs are running:
```json
{
"status": "False",
"type": "JobControllerProgressing",
"reason": "AsExpected"
}
```
Cleanup Jobs may complete and be deleted before you can observe them. To verify they ran, check Kubernetes events on the ScyllaDBDatacenter resource:
```bash
kubectl get events --field-selector involvedObject.name=
```
Events are emitted by the resource apply framework when Jobs are created, updated, or deleted.
## Known limitations
### Replication factor changes are not detected
Decreasing the replication factor of a keyspace does not change the token ring — the same nodes own the same token ranges, but fewer replicas are needed. The Operator does not detect this and does not trigger cleanup. Run cleanup manually:
```bash
kubectl exec -it service/-client -c scylla -- nodetool cleanup
```
### Unnecessary cleanup on decommission
When a node is decommissioned, the remaining nodes inherit its tokens. They do not lose any tokens and therefore do not strictly need cleanup. The Operator triggers cleanup anyway because the token ring changed. The operation is safe but adds temporary I/O load.
## Related pages
- [Understand](https://operator.docs.scylladb.com/stable/understand/index.md) — component diagram and reconciliation model.
- [Sidecar](https://operator.docs.scylladb.com/stable/understand/sidecar.md) — the sidecar that reports node status used for stability checks.
# back-up-and-restore.md
# Back up and restore
ScyllaDB Operator supports automated backup and restore through [ScyllaDB Manager](https://operator.docs.scylladb.com/stable/understand/manager.md) using the ScyllaDBManagerTask CRD.
The Manager Agent sidecar on each ScyllaDB pod uploads snapshots to a [supported backup destination](https://manager.docs.scylladb.com/stable/backup/index.html).
## Guides
- [Restore from backup](https://operator.docs.scylladb.com/stable/operate/restore-from-backup.md) — Restore a ScyllaDB cluster from a Manager backup snapshot.
# bootstrap-sync.md
# Bootstrap synchronisation
This page explains why bootstrap synchronisation exists, how the barrier mechanism works, and how node statuses are propagated across the cluster.
#### WARNING
Due to a known bug, the barrier can block new nodes from bootstrapping while a decommission (scale-down) is in progress. This is most disruptive when the decommission cannot complete on its own, such as when the remaining nodes are too few to satisfy the keyspace replication factor, because adding nodes is the usual remedy. To work around this, [set the force annotation]() on the member Services of the nodes being added.
## The problem
[ScyllaDB requires that no node in the cluster considers any other node to be down when a new node joins.](https://docs.scylladb.com/manual/stable/operating-scylla/procedures/cluster-management/add-node-to-cluster.html#check-the-status-of-nodes)
If this precondition is not met and a non-idempotent bootstrap operation begins, the coordinator denies the join request and leaves the new node in a state that is difficult to recover from automatically.
In Kubernetes, multiple pods can start simultaneously — for example, when a StatefulSet scales up or when pods are rescheduled after a disruption. Without coordination, a new node could attempt to bootstrap while another node is still restarting and appears down to its peers.
## How the barrier works
When the `BootstrapSynchronisation` feature gate is enabled, the Operator adds an **init container** (`scylladb-bootstrap-barrier`) to every ScyllaDB pod. This init container runs before the ScyllaDB process starts and gates the bootstrap on a precondition check.
### Decision flow
1. **Already bootstrapped?** — The init container inspects the data directory for existing SSTables. If the node has already completed bootstrap (the `bootstrapped` column in `system.local` reads `COMPLETED`), the barrier exits immediately. Restarting nodes are never blocked.
2. **Force annotation set?** — If the node’s member Service carries the annotation `scylla-operator.scylladb.com/force-proceed-to-bootstrap: "true"`, the barrier exits immediately, bypassing the precondition. The annotation can also be set on the `ScyllaCluster` resource, which propagates it to all member Services in the datacenter.
3. **Replacing a dead node?** — If the node is being added as a replacement (the replacement label is present on the Service), the barrier exits immediately. Replacement has its own prerequisites that are outside the scope of this mechanism.
4. **Precondition check** — The init container watches internal node-status report resources (`ScyllaDBDatacenterNodesStatusReport`) and evaluates whether every reporting node in the cluster sees every other node as `UP`. The barrier blocks until this condition is satisfied.
## Node status propagation
Node statuses flow through a two-stage pipeline:
### Stage 1 — Sidecar reports per-node status
A `StatusReporter` controller runs inside the sidecar container on every ScyllaDB pod. It periodically calls the local ScyllaDB node’s storage service API to get the current gossip view — which nodes are seen as `UP` or `DOWN`. The result is written as a JSON-encoded annotation on the pod.
### Stage 2 — Datacenter controller assembles the report
On each reconciliation, the internal datacenter controller collects the reported statuses and assembles them into an internal `ScyllaDBDatacenterNodesStatusReport` custom resource. Only nodes that have joined the ScyllaDB cluster and own normal tokens in it are included, so the report covers ScyllaDB nodes rather than the Kubernetes objects representing them. A node that is still bootstrapping has no entry, and a missing entry doesn’t imply the node is unhealthy. This resource is namespaced and contains a nested structure:
```default
ScyllaDBDatacenterNodesStatusReport
├── datacenterName (gossip DC name)
└── racks[]
├── name
└── nodes[]
├── ordinal
├── hostID
└── observedNodes[]
├── hostID (of the observed node)
└── status ("UP" or "DOWN")
```
Each node entry records how that node sees every other node in the cluster.
#### NOTE
`ScyllaDBDatacenterNodesStatusReport` is an internal resource used by the Operator for coordinating operations. It is not intended for direct user interaction.
## Precondition evaluation
The precondition is satisfied when **every** reporting node (excluding the node being bootstrapped) sees **every** other node as `UP`. Specifically:
- Every node must have a host ID.
- Every node must have submitted a status report.
- In each node’s report, every other node’s host ID must appear with status `UP`.
If any node is missing a host ID, has not yet reported, does not list another node, or reports another node as `DOWN`, the precondition is not satisfied and the barrier continues to wait.
## Feature gate and version requirements
| Requirement | Value |
|--------------------------|------------------------------------------------------|
| Feature gate | `BootstrapSynchronisation` (default off since v1.19) |
| Minimum ScyllaDB version | 2025.2 |
The feature gate must be enabled in the Operator’s command-line flags. The Operator also checks the ScyllaDB container image version and only adds the init container when the version satisfies `≥ 2025.2.0`.
See [Feature gates](https://operator.docs.scylladb.com/stable/reference/feature-gates.md) for instructions on enabling feature gates.
## Limitations
- **Node replacement** — Bootstrap synchronisation does not apply to nodes being added as replacements for dead nodes. You must verify the [replacement prerequisites](https://docs.scylladb.com/manual/stable/operating-scylla/procedures/cluster-management/replace-dead-node.html#prerequisites) manually.
- **Manual multi-DC with ScyllaCluster** — When multiple `ScyllaCluster` resources are manually configured as a multi-datacenter cluster, node statuses can only be propagated within a single datacenter. Check node status in all datacenters manually before adding nodes.
- **Alpha status** — The feature is opt-in while ScyllaDB versions prior to 2025.2 are still supported by the Operator.
## Overriding the precondition
In scenarios where you need to bypass the barrier for a specific node or an entire datacenter, apply the force annotation:
Single node
```bash
kubectl annotate service \
scylla-operator.scylladb.com/force-proceed-to-bootstrap=true
```
Entire datacenter
```bash
kubectl -n= annotate scyllacluster \
scylla-operator.scylladb.com/force-proceed-to-bootstrap=true
```
The annotation is propagated from the `ScyllaCluster` through the internal `ScyllaDBDatacenter` resource (which shares the same name) to all member Services in the datacenter.
## Related pages
- [Ignition](https://operator.docs.scylladb.com/stable/understand/ignition.md) — the startup gating mechanism that runs after the bootstrap barrier.
- [Sidecar](https://operator.docs.scylladb.com/stable/understand/sidecar.md) — the sidecar container that runs the StatusReporter.
- [Understand](https://operator.docs.scylladb.com/stable/understand/index.md) — component diagram and CRD list.
# change-log-level.md
# Change log level on a live cluster
Change the ScyllaDB log level without a full rolling restart.
This is useful when a rolling restart is not feasible — for example, when a StatefulSet is stuck mid-rollout or the cluster is degraded.
## When to use each method
| Scenario | Method | Persistent? |
|------------------------------------------------------|-----------------|--------------------------|
| Normal operations — rolling restart is acceptable | [Spec change]() | Yes |
| StatefulSet stuck mid-rollout | [REST API]() | No — lost on pod restart |
| Cluster degraded — cannot tolerate a rolling restart | [REST API]() | No — lost on pod restart |
## Method 1: Spec change (rolling restart)
Add the log level argument to the ScyllaCluster spec:
```yaml
apiVersion: scylla.scylladb.com/v1
kind: ScyllaCluster
metadata:
name: my-cluster
namespace: scylla
spec:
# ... existing configuration ...
scyllaArgs: "--default-log-level=debug"
```
Apply the change:
```bash
kubectl apply --server-side -f scylla-cluster.yaml
```
ScyllaDB Operator performs a rolling restart to apply the new argument.
See [Passing ScyllaDB arguments](https://operator.docs.scylladb.com/stable/operate/pass-scylladb-arguments.md) for details.
## Method 2: REST API (no restart)
Use the ScyllaDB REST API to change the log level on running pods without triggering a rollout.
### Change log level on a single pod
```bash
kubectl -n scylla exec -c scylla -- \
curl -s -X POST "http://localhost:10000/system/logger/?level="
```
Where:
- `` is the logger to adjust (e.g., `compaction`, `gossip`, `storage_proxy`)
- `` is the desired level: `error`, `warn`, `info`, `debug`, `trace`
To set **all** loggers at once, omit the logger name from the path:
```bash
kubectl -n scylla exec -c scylla -- \
curl -s -X POST "http://localhost:10000/system/logger?level="
```
**Example — set all loggers to debug:**
```bash
kubectl -n scylla exec -c scylla -- \
curl -s -X POST "http://localhost:10000/system/logger?level=debug"
```
### Change log level on all pods
```bash
NAMESPACE=scylla
CLUSTER=my-cluster
for pod in $(kubectl -n "${NAMESPACE}" get pods \
-l scylla/cluster="${CLUSTER}" \
-l scylla-operator.scylladb.com/pod-type=scylladb-node \
-o jsonpath='{.items[*].metadata.name}'); do
echo "Setting log level on ${pod}..."
kubectl -n "${NAMESPACE}" exec "${pod}" -c scylla -- \
curl -s -X POST "http://localhost:10000/system/logger?level=debug"
done
```
### Verify the change
Check the level of a specific logger:
```bash
kubectl -n scylla exec -c scylla -- \
curl -s "http://localhost:10000/system/logger/compaction"
```
The response is the current log level (e.g., `"debug"`).
### Important notes
- **Debug and trace levels** generate significantly more log output and can impact performance.
Revert to `info` once you have collected the needed diagnostics.
- In a stuck rollout scenario, ScyllaDB Operator cannot process spec changes because the rollout is blocked.
The REST API is the only way to change log levels on pods that are already running.
See [StatefulSets and racks](https://operator.docs.scylladb.com/stable/understand/statefulsets-and-racks.md) for why a stuck rollout blocks further updates (partition-based rolling updates).
## Related pages
- [Passing ScyllaDB arguments](https://operator.docs.scylladb.com/stable/operate/pass-scylladb-arguments.md)
- [StatefulSets and racks](https://operator.docs.scylladb.com/stable/understand/statefulsets-and-racks.md)
# concepts-for-k8s-beginners.md
# ScyllaDB Concepts on Kubernetes
If you are familiar with ScyllaDB but new to Kubernetes, this page maps the ScyllaDB concepts you already know to their Kubernetes equivalents when running ScyllaDB with the Operator.
## Concept mapping
| ScyllaDB concept | Kubernetes equivalent | Notes |
|-------------------------------|---------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| **ScyllaDB node** | ScyllaDB **Pod**, **node service** and **PVC** | Each ScyllaDB node runs inside a Kubernetes pod. A pod is the smallest deployable unit in Kubernetes and contains one or more containers. The node service is a Kubernetes service that allows connectivity to that node and stores some of its runtime metadata. The PVC (PersistentVolumeClaim) provides persistent storage for keyspaces. |
| **ScyllaDB process** | **Container** (inside the pod) | The ScyllaDB process runs inside a container within the pod. The pod also contains sidecar containers for monitoring, tuning, and management. |
| **Datacenter** | **`ScyllaCluster`** | A `ScyllaCluster` resource represents one ScyllaDB datacenter. For multi-DC setups, create one `ScyllaCluster` per datacenter in each Kubernetes cluster and connect them using `externalSeeds`. |
| **Rack** | **StatefulSet** | Each rack in the ScyllaCluster spec maps to a Kubernetes StatefulSet. The StatefulSet guarantees stable pod names, persistent storage, and ordered startup/shutdown. |
| **Cluster** | **`ScyllaCluster`** resource (one per datacenter) | You declare the desired cluster state as a YAML resource. The Operator continuously reconciles the actual state to match. For multi-DC clusters, create one `ScyllaCluster` per datacenter and connect them via `externalSeeds`. |
| **`scylla.yaml` config file** | **ConfigMap** referenced by `scyllaConfig` | ScyllaDB configuration is stored in a Kubernetes ConfigMap and referenced from the ScyllaCluster spec. The Operator also generates configuration automatically. |
| **Data directory** | **PersistentVolumeClaim (PVC)** | Each ScyllaDB node’s data is stored on a PersistentVolume, provisioned via a PVC. Data survives pod restarts. |
| **Node IP / listen address** | **Service** (per member) | Each ScyllaDB node gets a dedicated Kubernetes Service that provides a stable network identity, independent of pod restarts. |
| **Seed nodes** | Managed automatically | The Operator selects seed nodes and configures them. You do not need to manage seeds manually. |
| **`nodetool`** | `kubectl exec` + `nodetool` | Run `nodetool` commands by executing into the ScyllaDB container: `kubectl exec -it -c scylla -- nodetool status`. Read-only commands are safe; state-changing commands are (mostly) disallowed; see [nodetool alternatives](https://operator.docs.scylladb.com/stable/reference/nodetool-alternatives.md). |
| **Repair / Backup tasks** | **ScyllaDBManagerTask** resource or cluster spec fields | Instead of running `sctool` commands, you declare tasks as Kubernetes resources or in the ScyllaCluster spec. |
## Understanding pod names
ScyllaDB pod names follow a predictable pattern:
```default
---
```
For example, `scylladb-us-east-1-us-east-1a-0` is:
- Cluster: `scylladb`
- Datacenter: `us-east-1`
- Rack: `us-east-1a`
- Ordinal: `0` (first node in the rack)
The ordinal is zero-based. When you scale up a rack, new nodes get the next ordinal. When you scale down, the node with the highest ordinal is removed.
## Key differences from bare-metal ScyllaDB
| Aspect | Bare metal | Kubernetes with Operator |
|-----------------------------|------------------------------------------------------------|----------------------------------------------------------------------------------------------------------|
| **Starting/stopping nodes** | `systemctl start/stop scylla` | The Operator manages pod lifecycle. Delete a pod to restart it; the Operator recreates it automatically. |
| **Adding nodes** | Install ScyllaDB on a new machine, configure seeds, start. | Increase `members` in the rack spec. The Operator handles everything. |
| **Removing nodes** | Run `nodetool decommission`, then shut down. | Decrease `members` in the rack spec. The Operator runs decommission before removing the pod. |
| **Replacing a dead node** | Start a new node with `replace_address_first_boot`. | Label the node’s Service for replacement. The Operator handles the rest. |
| **Configuration changes** | Edit `scylla.yaml` and restart. | Update the ConfigMap or ScyllaCluster spec. The Operator performs a rolling restart. |
| **Monitoring** | Deploy monitoring stack manually. | Create a `ScyllaDBMonitoring` resource. |
| **Upgrades** | Update packages, restart nodes one by one. | Change the `version` field. The Operator performs a rolling upgrade. |
## Kubernetes failure states and what they mean for ScyllaDB
When troubleshooting, you may encounter these Kubernetes-specific states:
| State | What it means | What to check |
|---------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------|
| **Pending** | The pod cannot be scheduled onto a node. Common causes: no nodes match the affinity/toleration rules, or insufficient CPU/memory resources on available nodes. | Node resources, node selectors, taints/tolerations, PVC binding. |
| **CrashLoopBackOff** | The container keeps crashing and Kubernetes is backing off before restarting. ScyllaDB is starting then crashes repeatedly. Common causes: misconfigured `scylla.yaml`, insufficient memory, corrupt data on the PVC, or init containers not completing. | Container logs (`kubectl logs --previous`), ScyllaDB startup errors. |
| **ImagePullBackOff** | Kubernetes cannot pull the container image. Check the image tag, registry access from the node, and any pull secrets. | Image name/tag, registry credentials, network connectivity. |
| **Init:0/N** | Init containers have not completed yet. An init container has not yet completed. Possible causes: the bootstrap barrier is waiting for a prerequisite, or a sidecar init is failing. | Init container logs, NodeConfig status, bootstrap barrier. |
| **Running but not Ready** | The container is running but the readiness probe is failing. | ScyllaDB may still be starting up, or it may be unhealthy. Check logs. |
For detailed troubleshooting procedures, see the [troubleshooting guide](https://operator.docs.scylladb.com/stable/troubleshoot/index.md).
# conditions.md
# Conditions reference
The ScyllaDB Operator uses Kubernetes status conditions to communicate health and progress of managed resources.
This page documents the top-level condition types, their semantics, and aggregation rules.
These conditions apply to all Operator-managed custom resources that report status conditions (e.g. `ScyllaCluster`, `ScyllaDBDatacenter`, `NodeConfig`).
## Top-level conditions
Every condition-reporting resource exposes three top-level conditions:
| Condition type | Meaning when `True` | Meaning when `False` | Meaning when `Unknown` |
|------------------|--------------------------------------------------------------------------------|--------------------------------|-----------------------------------------------|
| `Available` | The resource is functional and can serve its purpose | The resource is not functional | Availability cannot yet be determined |
| `Progressing` | The Operator is actively reconciling (rolling update, scaling, version change) | Either completed or stuck | Reconciliation state cannot yet be determined |
| `Degraded` | Something is unhealthy or an error occurred during reconciliation | Resource is healthy | Health cannot yet be determined |
A fully healthy, quiescent resource shows: `Available=True`, `Progressing=False`, `Degraded=False`.
A resource can be `Available=True` and `Degraded=True` simultaneously — for example, a `ScyllaCluster` where two of three nodes are healthy can still serve traffic but is not fully healthy.
`Available` reflects whether the resource *can* serve its purpose, not whether it is in a *fully* healthy state.
## Aggregation rules
The top-level conditions are computed from per-controller sub-conditions.
Each internal controller contributes a condition whose type is prefixed with the controller name and ends with `Available`, `Progressing`, or `Degraded` (e.g. `StatefulSetControllerDegraded`, `JobControllerProgressing`).
The aggregation logic is:
- **`Available=True`** requires **all** `*Available` sub-conditions to be `True`.
- **`Progressing=True`** when **any** `*Progressing` sub-condition is `True`.
- **`Degraded=True`** when **any** `*Degraded` sub-condition is `True`.
To inspect all conditions on a `ScyllaCluster` (including sub-conditions), run:
```bash
kubectl -n scylla get scyllacluster \
-o jsonpath='{range .status.conditions[*]}{.type}: {.status} — {.reason}: {.message}{"\n"}{end}'
```
## Condition fields
Each condition object contains:
| Field | Description |
|----------------------|--------------------------------------------------------------------|
| `type` | Condition name (e.g. `Available`, `StatefulSetControllerDegraded`) |
| `status` | `True`, `False`, or `Unknown` |
| `reason` | A CamelCase machine-readable reason string |
| `message` | A human-readable description of the current state |
| `lastTransitionTime` | When the condition last changed |
| `observedGeneration` | The `metadata.generation` the condition was computed from |
## Related pages
- [Investigate restarts](https://operator.docs.scylladb.com/stable/troubleshoot/investigate-restarts.md) — using conditions alongside pod events
# configure-coredumps.md
# Collect core dumps
This guide explains how to configure core dump collection on Kubernetes nodes running ScyllaDB Operator-managed ScyllaDB clusters and how to retrieve the resulting dump files.
## Background
Core dump handling is controlled by `kernel.core_pattern` (see Linux [man page](https://man7.org/linux/man-pages/man5/core.5.html)). In Kubernetes, writing dumps to an absolute path inside the container means they are lost on pod restart.
We recommend piping dumps through the `systemd-coredump` tool, which stores them on the host filesystem independently of pod lifetime.
## Platform requirements
Collecting a core dump requires the following prerequisites on the Kubernetes worker node where the process expected to crash is scheduled. To make things simpler, it can be done on all worker nodes.
This must be completed **before the anticipated crash**.
1. **`systemd-coredump` installed** - the helper binary that receives the core image from the kernel and writes it to disk.
2. **`/etc/systemd/coredump.conf` configured** - controls storage location (`Storage=external`), compression (`Compress=yes`), and disk space limits (`MaxUse`, `KeepFree`, `ProcessSizeMax`, `ExternalSizeMax`).
3. **`kernel.core_pattern` set** to pipe crashes through `systemd-coredump`.
4. **`systemd-coredump.socket` active**.
A ready-to-use setup for GKE is provided below. On other platforms, apply these four steps using the OS package manager and systemd tooling available on the node.
## Set up core dump collection on GKE
GKE Ubuntu nodes do not ship `systemd-coredump` by default. The two manifests below handle all four setup steps via a single container on each ScyllaDB node. The container performs the setup once at startup and then sleeps, keeping the pod alive so that the DaemonSet re-applies the settings whenever the pod is evicted or rescheduled.
### 1. Create the ConfigMap
```yaml
# Recommended systemd-coredump configuration for nodes running ScyllaDB.
#
# Apply this ConfigMap alongside the setup-systemd-coredump DaemonSet so that
# the setup container writes these settings to /etc/systemd/coredump.conf on
# each node before activating kernel.core_pattern.
#
# Key tuning choices (adjust to your environment, refer to `man 5 coredump.conf`):
# Storage=external - write core dump files to /var/lib/systemd/coredump/
# (as opposed to the systemd journal or tmpfs).
# Compress=yes - compress dumps with zstd (saves significant disk space).
# ProcessSizeMax=0 - do not truncate core dumps; ScyllaDB needs full cores.
# ExternalSizeMax=0
# MaxUse=20G - cap the total space used for stored dumps.
# KeepFree=10G - always leave at least this much free on the target filesystem.
#
# IMPORTANT: ScyllaDB processes may allocate hundreds of gigabytes of memory.
# Even compressed core dumps can be very large. Adjust MaxUse and KeepFree to
# match the size of your host boot disk (or a dedicated volume if you mount one
# at /var/lib/systemd/coredump/).
apiVersion: v1
kind: ConfigMap
metadata:
name: scylladb-coredump-conf
namespace: scylla-operator
labels:
app.kubernetes.io/name: scylladb-coredump-setup
data:
coredump.conf: |
[Coredump]
# Store core dumps as files on the host filesystem.
Storage=external
# Compress stored core dumps using zstd.
Compress=yes
# Do not truncate core dumps. ScyllaDB requires full core images for analysis.
ProcessSizeMax=0
ExternalSizeMax=0
# Maximum total disk space to use for all stored core dumps.
# Increase if your nodes have larger disks or if you expect many simultaneous crashes.
MaxUse=20G
# Always keep at least this much disk space free on the target filesystem.
KeepFree=10G
```
Download the manifest and edit `MaxUse` and `KeepFree` to match your environment before applying - see [Storage considerations]().
```bash
curl -fLO https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/examples/gke/coredumps/coredump-conf.configmap.yaml
```
```bash
vi coredump-conf.configmap.yaml
```
```bash
kubectl apply --server-side -f=coredump-conf.configmap.yaml
```
### 2. Deploy the setup DaemonSet
```yaml
# This DaemonSet installs and configures systemd-coredump on GKE nodes running
# ScyllaDB so that core dumps are captured and stored on the host filesystem at
# /var/lib/systemd/coredump/.
#
# GKE nodes use Ubuntu with apt-get as the package manager.
# systemd-coredump is not installed by default on GKE nodes; a single
# long-running container installs it and then performs the following setup steps:
# 1. Install the systemd-coredump package via apt-get.
# 2. Apply the recommended /etc/systemd/coredump.conf configuration.
# 3. Set kernel.core_pattern to pipe core dumps through systemd-coredump.
# 4. Start systemd-coredump.socket so the helper can connect to it when a
# crash occurs.
apiVersion: apps/v1
kind: DaemonSet
metadata:
name: scylladb-coredump-setup
namespace: scylla-operator
labels:
app.kubernetes.io/name: scylladb-coredump-setup
spec:
selector:
matchLabels:
app.kubernetes.io/name: scylladb-coredump-setup
template:
metadata:
labels:
app.kubernetes.io/name: scylladb-coredump-setup
spec:
# Target only the nodes that run ScyllaDB workloads.
nodeSelector:
scylla.scylladb.com/node-type: scylla
tolerations:
- key: scylla-operator.scylladb.com/dedicated
operator: Equal
value: scyllaclusters
effect: NoSchedule
# hostPID is required so that "nsenter -t 1" targets the host's systemd
# (PID 1) rather than the container's init process. This is needed for
# systemctl to communicate with the host's D-Bus and start
# systemd-coredump.socket.
hostPID: true
containers:
- name: setup-coredump
image: docker.io/library/ubuntu:24.04
imagePullPolicy: IfNotPresent
securityContext:
privileged: true
readinessProbe:
exec:
command:
- cat
- /tmp/setup-complete
initialDelaySeconds: 5
periodSeconds: 5
resources:
requests:
cpu: 1m
memory: 32Mi
limits:
cpu: 100m
memory: 128Mi
command:
- /bin/bash
- -euEo
- pipefail
- -O
- inherit_errexit
- -c
- |
# Run a command inside the host's mount + UTS namespaces using nsenter
# so that package managers and sysctl operate on the real host.
host_exec() {
nsenter --mount=/host/proc/1/ns/mnt --uts=/host/proc/1/ns/uts -- "$@"
}
echo "Installing systemd-coredump via apt-get..."
host_exec apt-get update -y -qq
host_exec apt-get install -y -qq systemd-coredump
# Apply the coredump configuration from the mounted ConfigMap.
if [ -f /config/coredump.conf ]; then
echo "Applying custom /etc/systemd/coredump.conf..."
cp /config/coredump.conf /host/etc/systemd/coredump.conf
nsenter -t 1 --mount --uts --ipc --net -- systemctl daemon-reload || true
fi
# Retrieve the path to the systemd-coredump helper binary.
# On GKE Ubuntu nodes this is /usr/lib/systemd/systemd-coredump.
SYSTEMD_COREDUMP_BIN="$(host_exec sh -c 'command -v systemd-coredump 2>/dev/null || echo /usr/lib/systemd/systemd-coredump')"
echo "Setting kernel.core_pattern to pipe through ${SYSTEMD_COREDUMP_BIN}..."
# The format string passes 8 positional arguments to the helper
# (systemd-coredump >= 252 requires exactly 8):
# %P PID of the crashing process (initial PID namespace)
# %u UID of the crashing process
# %g GID of the crashing process
# %s Signal number
# %t Unix timestamp of the crash
# 9223372036854775808 A large hardcoded value passed in place of %c (the core file size rlimit) to prevent truncation
# %h Hostname
# %d Directory fd - lets systemd-coredump read /proc/ metadata after the process exits
host_exec sysctl -w "kernel.core_pattern=|${SYSTEMD_COREDUMP_BIN} %P %u %g %s %t 9223372036854775808 %h %d"
echo "kernel.core_pattern is now:"
host_exec sysctl -n kernel.core_pattern
# Start systemd-coredump.socket on the host so the helper can hand off
# the core image for processing. Without an active socket the helper
# exits silently and no core file is written.
# nsenter -t 1 with mount+UTS+IPC+net namespaces makes the host binaries
# and the D-Bus socket visible to systemctl.
echo "Starting systemd-coredump.socket on the host..."
nsenter -t 1 --mount --uts --ipc --net -- systemctl start systemd-coredump.socket
echo "systemd-coredump.socket is now active."
# Keep the pod running so that the DaemonSet re-applies the settings
# on eviction or reschedule.
echo "Setup complete. Sleeping indefinitely..."
touch /tmp/setup-complete
exec sleep infinity
volumeMounts:
- name: host
mountPath: /host
- name: coredump-config
mountPath: /config
readOnly: true
volumes:
- name: host
hostPath:
path: /
type: Directory
- name: coredump-config
configMap:
name: scylladb-coredump-conf
updateStrategy:
type: RollingUpdate
```
```bash
kubectl apply --server-side -f=https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/examples/gke/coredumps/setup-systemd-coredump.daemonset.yaml
```
Wait for the DaemonSet to roll out on all ScyllaDB nodes:
```bash
kubectl -n scylla-operator rollout status daemonset/scylladb-coredump-setup
```
### 3. Verify the configuration
After the DaemonSet rolls out, confirm `kernel.core_pattern` is correctly set on each node. List the dedicated ScyllaDB nodes:
```bash
kubectl get nodes -l scylla.scylladb.com/node-type=scylla -o name
```
Run the following command for each node, replacing `` with the actual name:
```bash
kubectl debug node/ -it --profile=sysadmin --image=docker.io/library/ubuntu:24.04 -- \
nsenter --mount=/proc/1/ns/mnt -- sysctl -n kernel.core_pattern
```
Expected output:
```console
|/usr/lib/systemd/systemd-coredump %P %u %g %s %t 9223372036854775808 %h %d
```
Also verify that `systemd-coredump.socket` is active:
```bash
kubectl debug node/ -it --profile=sysadmin --image=docker.io/library/ubuntu:24.04 -- \
nsenter --mount=/proc/1/ns/mnt -- systemctl is-active systemd-coredump.socket
```
The output must be `active`.
## Verify that core dump collection works end to end
The steps below trigger a test crash of a running ScyllaDB process and confirm the dump was captured by `systemd-coredump`.
#### WARNING
This procedure intentionally crashes a ScyllaDB node. Only run it when the cluster can tolerate losing one member temporarily.
### 1. Find the pod and its node
```bash
NAMESPACE=
kubectl get pods -n "${NAMESPACE}" -l scylla-operator.scylladb.com/pod-type=scylladb-node -o wide
```
Store the pod name and the node it is scheduled on:
```bash
POD_NAME=
NODE_NAME=
```
### 2. Trigger the crash
Inside a pod managed by ScyllaDB Operator, the sidecar is PID 1 and the `scylla` binary runs as a child process. Send a `SIGABRT` signal to the `scylla` process to trigger a crash and core dump:
```bash
kubectl exec -n "${NAMESPACE}" "${POD_NAME}" -c scylla -- sh -c 'kill -ABRT $(pgrep -x scylla)'
```
ScyllaDB logs a backtrace and terminates. The pod stays running because the ScyllaDB Operator sidecar (PID 1) is unaffected; ScyllaDB Operator will restart the ScyllaDB process automatically. The dump is written to the node’s host filesystem before the process exits.
### 3. Confirm the dump was captured
Confirm the dump was captured using coredumpctl list - see [Retrieving core dumps from nodes]() for details.
## Retrieve core dumps from nodes
Core dumps are stored at `/var/lib/systemd/coredump/` on the host.
### 1. List available dumps
```bash
kubectl debug "node/${NODE_NAME}" -it --profile=sysadmin --image=docker.io/library/ubuntu:24.04 -- \
nsenter --mount=/proc/1/ns/mnt -- coredumpctl list
```
Store the PID of the desired dump from the output:
```bash
DUMP_PID=
```
### 2. Export a specific dump
Start a debug pod on the node so that we can use `kubectl exec` to retrieve the dump file:
```bash
kubectl debug "node/${NODE_NAME}" --profile=sysadmin --image=docker.io/library/ubuntu:24.04 -- sleep 3600
```
Store the debug pod name:
```bash
DEBUG_POD_NAME=
```
Pull the dump file from the node to your local machine (it can be very large, so this may take some time):
```bash
kubectl exec "${DEBUG_POD_NAME}" -- \
nsenter --mount=/proc/1/ns/mnt -- coredumpctl dump "${DUMP_PID}" \
> scylla.core
```
You can verify the dump with `file scylla.core` - it should show ELF 64-bit LSB core file.
## Storage considerations
Take into account that ScyllaDB core dumps can be very large. You will need spare disk space larger than that of ScyllaDB’s RAM. Core dump storage is controlled by the `[Coredump]` section of `/etc/systemd/coredump.conf`.
#### NOTE
`systemd-coredump` will automatically delete the oldest dump files when the `MaxUse` or `KeepFree` thresholds are exceeded, so some dumps may be lost if a node generates many crashes in a short period of time and the disk is nearly full.
To avoid losing dumps due to insufficient disk space, consider the following:
- **Attach a dedicated disk** to each ScyllaDB node at `/var/lib/systemd/coredump/` so core dumps do not compete with the OS for disk space.
- **Offload dumps to object storage** - the [IBM core-dump-handler](https://github.com/IBM/core-dump-handler) project provides a Helm chart that installs a similar `kernel.core_pattern` pipe handler and automatically uploads dumps to an S3-compatible bucket. This is a good option if you need centralized, long-term dump storage.
# configure-cpu-pinning.md
# Configure CPU pinning
CPU pinning ensures that ScyllaDB threads are bound to specific CPU cores, eliminating context-switch overhead and improving tail latency.
## Why CPU pinning matters
ScyllaDB is a shard-per-core database — it assigns each CPU core a dedicated share of data and I/O.
When the kernel schedules other processes or handles interrupts on those same cores, it disrupts ScyllaDB’s per-core processing and causes latency spikes.
CPU pinning ensures:
- The kubelet assigns **exclusive CPU cores** to the ScyllaDB container.
- The [`perftune.py`](https://github.com/scylladb/seastar/blob/master/scripts/perftune.py) tuning script configures **IRQ affinity** so that network and disk interrupts are handled by CPUs **not** assigned to ScyllaDB.
- ScyllaDB starts with `--overprovisioned=0`, telling it to assume dedicated cores and optimize accordingly.
## Prerequisites
CPU pinning requires three things to work together:
| Requirement | Who configures it |
|--------------------------------------------|--------------------------------------------------|
| Kubelet static CPU manager policy | Platform administrator (node pool configuration) |
| Guaranteed QoS class on the ScyllaDB Pod | `ScyllaCluster` author |
| Performance tuning enabled in `NodeConfig` | `NodeConfig` author (enabled by default) |
If any of these is missing, CPU pinning silently does not apply.
## Enable the static CPU manager policy
The kubelet on each dedicated ScyllaDB node must be started with `cpuManagerPolicy: static`.
This tells the kubelet to assign exclusive CPUs to containers that request integer CPU amounts in Pods with Guaranteed QoS class.
How you configure this depends on your platform:
GKE
Pass a `systemconfig.yaml` file when creating the node pool:
```console
cat > systemconfig.yaml < 9042
```
Replace `` with the address shown in the Service output.
## Related pages
- [Discovery endpoint](https://operator.docs.scylladb.com/stable/connect-your-app/discovery.md) — exposing the discovery Service.
- [Connect via CQL](https://operator.docs.scylladb.com/stable/connect-your-app/connect-via-cql.md) — client connection setup.
- [Networking architecture](https://operator.docs.scylladb.com/stable/understand/networking.md) — how Services and expose options work.
- [Security](https://operator.docs.scylladb.com/stable/understand/security.md) — TLS certificate management.
# configure-io-properties.md
# Configure precomputed IO properties
Provide precomputed IO properties to ScyllaDB to skip the automatic `iotune` benchmark that runs on first startup.
## When to use this
By default, ScyllaDB runs an `iotune` benchmark when a node starts for the first time.
The benchmark measures the IO capabilities of the underlying storage and writes the results to `io_properties.yaml`.
The results are cached on the persistent volume, so subsequent startups reuse them.
Running the benchmark is appropriate for most deployments.
However, you may want to provide precomputed values when:
- You know the exact IO characteristics of your storage (e.g. cloud provider published IOPS/throughput specs).
- You want to ensure consistent IO configuration across all nodes.
- You want to skip the benchmark to speed up initial cluster bootstrap.
## How it works
The Operator’s sidecar checks for `/etc/scylla.d/io_properties.yaml` before starting ScyllaDB.
If the file exists, the sidecar passes `--io-setup=0 --io-properties-file=/etc/scylla.d/io_properties.yaml` to the ScyllaDB binary, which skips the iotune benchmark entirely.
If the file does not exist, the sidecar creates a symlink to a cache location on the persistent volume, where iotune results are stored after the first run.
To provide precomputed values, mount a ConfigMap containing `io_properties.yaml` into `/etc/scylla.d/` on the ScyllaDB container.
## Procedure
### Step 1: Create the IO properties ConfigMap
Create a ConfigMap containing your precomputed IO properties.
Refer to the [Seastar iotune source](https://github.com/scylladb/seastar/blob/master/apps/iotune/iotune.cc) for the file format reference.
```yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: scylla-io-properties
namespace: scylla
data:
io_properties.yaml: |
disks:
- mountpoint: /var/lib/scylla
read_iops: 200000
read_bandwidth: 1200000000
write_iops: 100000
write_bandwidth: 600000000
```
```bash
kubectl -n scylla apply -f io-properties-configmap.yaml
```
### Step 2: Mount the ConfigMap into the ScyllaDB container
ScyllaCluster
Use `volumes` and `volumeMounts` on the rack spec to mount the ConfigMap into the ScyllaDB container:
```yaml
apiVersion: scylla.scylladb.com/v1
kind: ScyllaCluster
metadata:
name: scylla
namespace: scylla
spec:
datacenter:
name: us-east-1
racks:
- name: us-east-1a
members: 3
storage:
capacity: 500Gi
resources:
limits:
cpu: 4
memory: 8Gi
volumes:
- name: io-properties
configMap:
name: scylla-io-properties
volumeMounts:
- name: io-properties
mountPath: /etc/scylla.d/io_properties.yaml
subPath: io_properties.yaml
readOnly: true
```
### Step 3: Apply and verify
Apply the cluster spec.
After the pods start, verify that the IO properties are being used:
```bash
kubectl -n scylla exec -it scylla-us-east-1-us-east-1a-0 -c scylla -- cat /etc/scylla.d/io_properties.yaml
```
You should see your precomputed values.
The ScyllaDB logs should show that iotune was skipped:
```bash
kubectl -n scylla logs scylla-us-east-1-us-east-1a-0 -c scylla | grep -i "io properties"
```
### Key considerations
| Consideration | Detail |
|-----------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------|
| Persistent cache | By default, iotune results are cached on the persistent volume. Precomputed values are only needed if you want to skip or override the benchmark. |
| Consistent values | All nodes sharing the same storage type should use the same IO properties. Mount the same ConfigMap across all racks that use the same storage class. |
| Rolling restart | Adding or changing the volume mount triggers a rolling restart. The Operator restarts nodes one at a time. |
| Storage class changes | If you change the storage class or move to a different disk type, update the IO properties ConfigMap to match the new storage. |
### Related pages
- [Pass additional ScyllaDB arguments](https://operator.docs.scylladb.com/stable/operate/pass-scylladb-arguments.md) — passing arbitrary command-line flags to ScyllaDB
- [Seastar iotune source](https://github.com/scylladb/seastar/blob/master/apps/iotune/iotune.cc) — reference for the `io_properties.yaml` format
# configure-nodes.md
# Configure nodes
ScyllaDB Operator uses the `NodeConfig` custom resource to prepare dedicated nodes for ScyllaDB.
`NodeConfig` handles local disk setup (RAID, filesystems, mounts) and kernel tuning (sysctls) automatically.
## What NodeConfig does
When you create a `NodeConfig` resource, the operator deploys a `DaemonSet` on matching nodes that:
1. **Configures local disks** — creates a RAID0 array from NVMe devices, formats it with XFS, and mounts it to a well-known path.
2. **Tunes kernel parameters** — sets sysctls for high-throughput I/O (`fs.aio-max-nr`, `fs.file-max`, `vm.swappiness`, etc.).
3. **Runs performance tuning** — executes `ContainerPerftune` Jobs for IRQ balancing and other low-latency optimizations.
## Matching placement
`NodeConfig` targets nodes using `placement` (with `nodeSelector` and `tolerations`).
These must match the same nodes where ScyllaDB Pods will run — if `NodeConfig` and `ScyllaCluster` target different node sets, performance tuning and disk setup will not apply to ScyllaDB Pods.
The recommended convention is label `scylla.scylladb.com/node-type: scylla` and taint `scylla-operator.scylladb.com/dedicated=scyllaclusters:NoSchedule`.
Both `NodeConfig` placement and `ScyllaCluster` rack placement must reference the same label and tolerate the same taint.
## Apply a NodeConfig
`NodeConfig` manifests are platform-specific because disk device paths and naming conventions differ.
GKE
```console
kubectl apply --server-side -f=https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/examples/gke/nodeconfig-alpha.yaml
```
EKS
```console
kubectl apply --server-side -f=https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/examples/eks/nodeconfig-alpha.yaml
```
OKE
```console
kubectl apply --server-side -f=https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/examples/oke/nodeconfig.yaml
```
OpenShift (ROSA)
```console
kubectl apply --server-side -f=https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/examples/openshift/rosa/nodeconfig.yaml
```
Wait for `NodeConfig` to finish reconciling:
```console
kubectl wait --timeout=10m --for='condition=Progressing=False' nodeconfigs.scylla.scylladb.com/scylladb-nodepool-1
kubectl wait --timeout=10m --for='condition=Degraded=False' nodeconfigs.scylla.scylladb.com/scylladb-nodepool-1
kubectl wait --timeout=10m --for='condition=Available=True' nodeconfigs.scylla.scylladb.com/scylladb-nodepool-1
```
## Disk setup
`NodeConfig` creates RAID arrays from local NVMe instance storage, formats them with XFS, and mounts them for the Local CSI Driver.
The setup pipeline runs in order: loop devices (if configured) → RAID arrays → filesystems → mounts.
After this, the Local CSI Driver can provision `PersistentVolumes` from directories on the mount point.
### XFS metadata options
For XFS filesystems, ScyllaDB recommends disabling `rmapbt` and `reflink`
when formatting local disks for ScyllaDB data. These XFS features are not
needed for ScyllaDB local data volumes and add filesystem metadata overhead.
Configure these options with `spec.localDiskSetup.filesystems[].flags`. The
Operator passes the configured flags to `mkfs` in the order listed.
```yaml
localDiskSetup:
filesystems:
- device: /dev/md0
type: xfs
flags:
- "-m"
- "rmapbt=0"
- "-m"
- "reflink=0"
```
The `-m` arguments are included explicitly because the Operator does not add
filesystem-specific `mkfs` options implicitly.
### Platform differences
GKE
Devices are matched by path only:
```yaml
raids:
- name: nvmes
type: RAID0
RAID0:
devices:
nameRegex: ^/dev/nvme\d+n\d+$
```
EKS
EKS nodes may have an NVMe root volume alongside instance storage.
Use `modelRegex` to select only instance storage devices:
```yaml
raids:
- name: nvmes
type: RAID0
RAID0:
devices:
modelRegex: Amazon EC2 NVMe Instance Storage
nameRegex: ^/dev/nvme\d+n\d+$
```
OKE
OKE `DenseIO` shapes expose NVMe devices at `/dev/nvme*`.
Devices are matched by path only (same as GKE):
```yaml
raids:
- name: nvmes
type: RAID0
RAID0:
devices:
nameRegex: ^/dev/nvme\d+n\d+$
```
OpenShift (ROSA)
ROSA on AWS uses the same instance families as EKS.
Use `modelRegex` to select only instance storage devices:
```yaml
raids:
- name: nvmes
type: RAID0
RAID0:
devices:
modelRegex: Amazon EC2 NVMe Instance Storage
nameRegex: ^/dev/nvme\d+n\d+$
```
Loop device (development)
For environments without local NVMe storage, `NodeConfig` can create a loop-backed device:
```yaml
localDiskSetup:
loopDevices:
- name: persistent-volumes
imagePath: /var/lib/persistent-volumes.img
size: 80Gi
filesystems:
- device: /dev/loops/persistent-volumes
type: xfs
mounts:
- device: /dev/loops/persistent-volumes
mountPoint: /var/lib/persistent-volumes
unsupportedOptions:
- prjquota
```
#### NOTE
The `prjquota` mount option is **required** for the Local CSI Driver.
It enables XFS project quotas, which the driver uses to enforce per-volume capacity limits.
### XFS online discard
On SSD-backed storage, enabling `discard` allows the filesystem to issue TRIM commands in real time, helping the SSD controller maintain write performance.
This is preferred over periodic `fstrim` which can cause latency spikes on a busy ScyllaDB node.
```yaml
mounts:
- device: /dev/md/nvmes
mountPoint: /var/lib/persistent-volumes
unsupportedOptions:
- prjquota
- discard
```
## Kernel parameters
Add the following to the `sysctls` field in your `NodeConfig` manifest.
These are the recommended values for ScyllaDB workloads:
```yaml
sysctls:
- name: fs.aio-max-nr
value: "30000000"
- name: fs.file-max
value: "9223372036854775807"
- name: fs.nr_open
value: "1073741816"
- name: fs.inotify.max_user_instances
value: "1200"
- name: vm.swappiness
value: "1"
- name: vm.vfs_cache_pressure
value: "2000"
```
### fs.nr_open and RLIMIT_NOFILE
ScyllaDB opens a large number of file descriptors — one per shard for each SSTable, plus connections and internal handles.
The kernel parameter `fs.nr_open` sets the **maximum value** that `RLIMIT_NOFILE` (the per-process file descriptor limit) can be raised to.
The Operator automatically raises `RLIMIT_NOFILE` on the ScyllaDB process to the value of `fs.nr_open`.
If `fs.nr_open` is too low (the default is 1,048,576), ScyllaDB may fail to open files under heavy load.
## Verify NodeConfig
Check that the `NodeConfig` reports healthy status:
```console
kubectl get nodeconfigs.scylla.scylladb.com
```
Expected output:
```default
NAME AVAILABLE PROGRESSING DEGRADED AGE
scylladb-nodepool-1 True False False 5m
```
## Install Local CSI Driver
The Local CSI Driver is needed for provisioning `PersistentVolumes` for `ScyllaClusters` using the mounted storage:
```console
kubectl -n=local-csi-driver apply --server-side -f=https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/examples/common/local-volume-provisioner/local-csi-driver/{00_clusterrole_def,00_clusterrole_def_openshift,00_clusterrole,00_namespace,00_scylladb-local-xfs.storageclass,10_csidriver,10_serviceaccount,20_clusterrolebinding,50_daemonset}.yaml
```
Wait for the driver to roll out:
```console
kubectl -n=local-csi-driver rollout status --timeout=10m daemonset.apps/local-csi-driver
```
# configure-operator.md
# Configure ScyllaDB Operator
This page explains how to configure ScyllaDB Operator’s global settings using the `ScyllaOperatorConfig` resource.
## Overview
`ScyllaOperatorConfig` is a cluster-scoped singleton resource named `cluster`. ScyllaDB Operator creates it automatically on startup if it does not exist. It holds global settings that affect all ScyllaDB clusters managed by ScyllaDB Operator, such as auxiliary container images and the Kubernetes cluster domain.
Most users do not need to modify this resource. ScyllaDB Operator ships with sensible defaults that are updated automatically when you upgrade.
## View the current configuration
```shell
kubectl get scyllaoperatorconfig cluster -o yaml
```
The `status` section shows the resolved values that are actually in use, including auto-discovered defaults:
```yaml
status:
scyllaDBUtilsImage: docker.io/scylladb/scylla:2025.1.9@sha256:...
scyllaDBNodeExporterImage: quay.io/prometheus/node-exporter:v1.11.1
bashToolsImage: registry.access.redhat.com/ubi9/ubi:9.5-...@sha256:...
grafanaImage: docker.io/grafana/grafana:12.2.0@sha256:...
prometheusVersion: v3.6.0
clusterDomain: cluster.local
```
## Configurable fields
| Spec field | Description | Default |
|----------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------|
| `scyllaUtilsImage` | ScyllaDB image used for running utility scripts (perftune, sysctl). Determines which tuning scripts are used for performance optimization. | Latest ScyllaDB image. |
| `scyllaDBNodeExporterImage` | `scylladb-node-exporter` image that ScyllaDB Operator runs as a sidecar to expose node-level OS metrics for ScyllaDB clusters. For versions before 2026.3.0, this field is ineffective because node-exporter is bundled and run directly within `scyllaDBImage`. | Latest scylladb-node-exporter image. |
| `configuredClusterDomain` | Kubernetes cluster domain. Must be a fully qualified domain name. | Auto-discovered via DNS lookup of `kubernetes.default.svc`. |
| `unsupportedBashToolsImageOverride` | Override the Bash tools image. **Unsupported** — for advanced use only. | UBI 9 image. |
| `unsupportedGrafanaImageOverride` | Override the Grafana image. **Unsupported** — for advanced use only. | Official Grafana image. |
| `unsupportedPrometheusVersionOverride` | Override the Prometheus version. **Unsupported** — for advanced use only. | Latest tested Prometheus version. |
## Change the ScyllaDB utils image
By default, ScyllaDB Operator uses performance tuning scripts from the latest ScyllaDB image. To use a different image, set `scyllaUtilsImage`:
```yaml
apiVersion: scylla.scylladb.com/v1alpha1
kind: ScyllaOperatorConfig
metadata:
name: cluster
spec:
scyllaUtilsImage: "docker.io/scylladb/scylla-enterprise:2026.2.5"
```
Apply the change:
```shell
kubectl apply --server-side -f scyllaoperatorconfig.yaml
```
The NodeConfig DaemonSet picks up the new image and uses Enterprise-specific tuning scripts on the next reconciliation.
## Set the cluster domain
ScyllaDB Operator auto-discovers the Kubernetes cluster domain by performing a DNS CNAME lookup for `kubernetes.default.svc`. If your cluster uses a non-standard domain or the auto-discovery does not work, set it explicitly:
```yaml
apiVersion: scylla.scylladb.com/v1alpha1
kind: ScyllaOperatorConfig
metadata:
name: cluster
spec:
configuredClusterDomain: my-cluster.local
```
The cluster domain is used internally for Kubernetes DNS resolution. Most users do not need to override it.
## How settings propagate
ScyllaOperatorConfig settings are consumed by several Operator controllers:
| Consumer | Setting used |
|-------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
| NodeConfig controller | `scyllaDBUtilsImage` — configures the tuning DaemonSet with the correct ScyllaDB image for `perftune.py` and resource limits. |
| ScyllaDBDatacenter controller | `scyllaDBNodeExporterImage` — configures the `scylladb-node-exporter` sidecar for ScyllaDB clusters running version 2026.3 or later. |
| ScyllaDBMonitoring controller | `grafanaImage`, `prometheusVersion` — configures the monitoring stack. |
Changes to `ScyllaOperatorConfig` trigger reconciliation in all dependent controllers. You do not need to restart Operator.
## Related pages
- [Configure nodes](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/configure-nodes.md) — performance tuning that uses the `scyllaUtilsImage`.
- [Set up monitoring](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-monitoring/index.md) — monitoring stack that uses the Grafana and Prometheus settings.
- [Tuning architecture](https://operator.docs.scylladb.com/stable/understand/tuning.md) — how tuning scripts are executed.
# configure-single-stack.md
# Configure IPv6-only networking
**What you’ll achieve**: Deploy a ScyllaDB cluster that uses only IPv6 for all communication.
**Before you begin**:
- You have a Kubernetes cluster with IPv6 support
- You have ScyllaDB Operator installed
- You have `kubectl` configured
- Your cluster and applications support IPv6-only operation
**After completion**: Your ScyllaDB cluster will use only IPv6 for all communication.
#### WARNING
**Experimental Feature**: IPv6-only configurations are experimental. See [Production readiness](https://operator.docs.scylladb.com/stable/reference/ipv6-configuration.md#production-readiness) for details. For production deployments, use [dual-stack with IPv4](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/configure-dual-stack.md) or [dual-stack with IPv6](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/configure-dual-stack.md#configure-dual-stack-networking-with-ipv6) instead.
## Step 1: Apply the configuration
Apply the IPv6-only configuration:
```shell
kubectl create namespace scylla
kubectl apply -f=https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/examples/ipv6/scylla-cluster-ipv6.yaml
```
## Step 2: Wait for the cluster to be ready
Monitor pod creation:
```bash
kubectl get pods -n scylla -l scylla-operator.scylladb.com/pod-type=scylladb-node -w
```
Wait until all pods show `Running` status.
## Step 3: Verify IPv6-only configuration
Check that pods have IPv6 addresses:
```bash
kubectl get pods -n scylla -l scylla-operator.scylladb.com/pod-type=scylladb-node -o wide
```
Expected output shows IPv6 addresses in the IP column:
```default
NAME READY STATUS RESTARTS AGE IP NODE
scylla-ipv6-datacenter-... 2/2 Running 0 5m fd00:10:244:1::7f scylla-worker-1
scylla-ipv6-datacenter-... 2/2 Running 0 4m fd00:10:244:2::6d scylla-worker-2
scylla-ipv6-datacenter-... 2/2 Running 0 3m fd00:10:244:3::6c scylla-worker-3
```
## Step 4: Verify cluster health
Check that all nodes are up:
```bash
NAMESPACE=scylla
CLUSTER_NAME=scylla-ipv6
pods=$(kubectl -n "${NAMESPACE}" get pods -l scylla/cluster="${CLUSTER_NAME}" -l scylla-operator.scylladb.com/pod-type=scylladb-node -o name)
for pod in ${pods}; do
kubectl -n "${NAMESPACE}" exec "${pod}" -c scylla -- nodetool status
done
```
Expected output shows IPv6 addresses:
```default
Datacenter: datacenter
======================
Status=Up/Down
|/ State=Normal/Leaving/Joining/Moving
-- Address Load Tokens Owns Host ID Rack
UN fd00:10:244:1::7f 501.79 KB 256 ? 4583fff5-2aa6-4041-9be8-c74bcabaff8c rack
UN fd00:10:244:2::6d 494.49 KB 256 ? b1f889b4-80e7-4685-a3c5-1b81797c2ce4 rack
UN fd00:10:244:3::6c 494.96 KB 256 ? 7a4bb6da-415e-4fc3-a6ca-0369c0e76bf0 rack
```
## Next steps
- [Troubleshoot IPv6 issues](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/troubleshooting.md)
# connect-via-cql.md
# Connect via CQL
This page explains how to connect to a ScyllaDB cluster running on Kubernetes using CQL (Cassandra Query Language).
## Authentication setup
For security, always enable authentication and authorization. Create a ConfigMap with the ScyllaDB configuration before deploying your cluster:
```yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: scylladb-config
data:
scylla.yaml: |
authenticator: PasswordAuthenticator
authorizer: CassandraAuthorizer
```
Reference this ConfigMap from your ScyllaCluster via `scyllaConfig` on each rack:
```yaml
apiVersion: scylla.scylladb.com/v1
kind: ScyllaCluster
metadata:
name: scylladb
spec:
datacenter:
racks:
- name: us-east-1a
scyllaConfig: scylladb-config
# ...
```
After deployment, follow the [Creating a Custom Superuser](https://docs.scylladb.com/manual/stable/operating-scylla/security/create-superuser.html) guide in the ScyllaDB documentation to replace the default `cassandra` superuser with a dedicated role.
## Embedded cqlsh
Every ScyllaDB Pod includes a built-in `cqlsh`. This is the simplest way to run queries:
Any node (via Service)
```shell
kubectl exec -it service/-client -c scylla -- cqlsh -u
```
Specific node
```shell
kubectl exec -it pod/--- -c scylla -- cqlsh -u
```
```default
Password:
Connected to scylla at 0.0.0.0:9042
[cqlsh 6.0.32 | Scylla 2026.1.0-0.20260309.9190d42863d4 | CQL spec 3.3.1 | Native protocol v4]
Use HELP for help.
@cqlsh>
```
## Remote cqlsh with TLS
ScyllaDB Operator configures TLS certificates automatically. The encrypted CQL port `9142` works by default.
### Prepare credentials and certificates
The Operator automatically creates TLS resources for each ScyllaCluster. For programmatic access using the Go driver with clusters that have `dnsDomains` configured, use the pre-built connection bundle from `secret/-local-cql-connection-configs-admin` directly (see [Security](https://operator.docs.scylladb.com/stable/understand/security.md) for details).
For `cqlsh`, extract the certificates and create a `cqlshrc` file:
**Step 1: Extract certificates**
```bash
kubectl -n scylla get configmap -local-serving-ca \
--template='{{ index .data "ca-bundle.crt" }}' > ca.crt
kubectl -n scylla get secret -local-user-admin \
-o jsonpath='{.data.tls\.crt}' | base64 -d > client.crt
kubectl -n scylla get secret -local-user-admin \
-o jsonpath='{.data.tls\.key}' | base64 -d > client.key
```
**Step 2: Create a cqlshrc file**
```bash
export SCYLLADB_CONFIG=/path/to/scylladb-config
mkdir -p "${SCYLLADB_CONFIG}"
cp ca.crt client.crt client.key "${SCYLLADB_CONFIG}/"
cat > "${SCYLLADB_CONFIG}/cqlshrc" <-client..svc
port = 9142
ssl = true
[ssl]
certfile = ${SCYLLADB_CONFIG}/ca.crt
usercert = ${SCYLLADB_CONFIG}/client.crt
userkey = ${SCYLLADB_CONFIG}/client.key
validate = true
[authentication]
username = cassandra
password =
EOF
```
### Connect
Native
```shell
cqlsh --cqlshrc="${SCYLLADB_CONFIG}/cqlshrc"
```
Podman
```shell
podman run -it --rm --entrypoint=cqlsh \
-v="${SCYLLADB_CONFIG}:${SCYLLADB_CONFIG}:ro,Z" \
-v="${SCYLLADB_CONFIG}/cqlshrc:/root/.cassandra/cqlshrc:ro,Z" \
docker.io/scylladb/scylla:2026.2.5
```
Docker
```shell
docker run -it --rm --entrypoint=cqlsh \
-v="${SCYLLADB_CONFIG}:${SCYLLADB_CONFIG}:ro" \
-v="${SCYLLADB_CONFIG}/cqlshrc:/root/.cassandra/cqlshrc:ro" \
docker.io/scylladb/scylla:2026.2.5
```
## Driver configuration tips
When using a ScyllaDB or Cassandra driver in your application:
| Setting | Recommended value | Why |
|------------------|------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------|
| Contact points | `-client..svc` (DNS) or the Service ClusterIP | Use the discovery Service, not individual Pod IPs. The driver discovers all nodes automatically. |
| Local datacenter | Your `datacenter.name` value (e.g., `us-east-1`) | Required for `DCAwareRoundRobinPolicy`. Prevents cross-DC queries. |
| Load balancing | Token-aware + DC-aware round robin | Sends queries directly to the replica owning the partition. |
| TLS | Enabled, with CA verification | Use the serving CA from `configmap/-local-serving-ca`. |
| Reconnection | Exponential backoff | Handles node restarts during rolling updates. |
## Related pages
- [Discovery endpoint](https://operator.docs.scylladb.com/stable/connect-your-app/discovery.md) — how the client Service works and how to expose it.
- [Alternator (DynamoDB API)](https://operator.docs.scylladb.com/stable/connect-your-app/alternator.md) — connecting via the DynamoDB-compatible API.
- [Configure external access](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/configure-external-access.md) — connecting from outside the Kubernetes cluster.
- [Security](https://operator.docs.scylladb.com/stable/understand/security.md) — TLS certificate management.
# deploy-multi-datacenter-cluster.md
# Deploy a multi-datacenter ScyllaDB cluster
This document describes the process of deploying a Multi Datacenter ScyllaDB cluster in multiple interconnected Kubernetes clusters.
This guide will walk you through the example procedure of deploying two datacenters in distinct regions of a selected cloud provider.
## Prerequisites
As this document describes the procedure of deploying a Multi Datacenter ScyllaDB cluster, you are expected to have the required infrastructure prepared.
Let’s assume two interconnected Kubernetes clusters, capable of communicating with each other over PodIPs, with each cluster meeting the following requirements:
- a node pool dedicated to ScyllaDB nodes composed of at least 3 nodes running in different zones (with unique `topology.kubernetes.io/zone` label), configured to run ScyllaDB, each labeled with `scylla.scylladb.com/node-type: scylla`
- running ScyllaDB Operator and its prerequisites
- running a storage provisioner capable of provisioning XFS volumes of StorageClass `scylladb-local-xfs` in each of the nodes dedicated to ScyllaDB instances
You can refer to one of our guides describing the process of preparing such infrastructure:
- [Build multiple Amazon EKS clusters with Inter-Kubernetes networking](https://operator.docs.scylladb.com/stable/install-operator/provision-infrastructure/multi-dc/set-up-multi-dc-eks-clusters.md)
- [Build multiple GKE clusters with Inter-Kubernetes networking](https://operator.docs.scylladb.com/stable/install-operator/provision-infrastructure/multi-dc/set-up-multi-dc-gke-clusters.md)
Additionally, to follow the below guide, you need to install and configure the following tools that you will need to manage Kubernetes resources:
- kubectl – A command line tool for working with Kubernetes clusters.
See [Install Tools](https://kubernetes.io/docs/tasks/tools/) in Kubernetes documentation for reference.
## Multi Datacenter ScyllaDB Cluster
In v1.11, ScyllaDB Operator introduced support for manual multi-datacenter ScyllaDB cluster deployments.
#### WARNING
ScyllaDB Operator only supports *manual configuration* of multi-datacenter ScyllaDB clusters.
In other words, although ScyllaCluster API exposes the machinery necessary for setting up multi-datacenter ScylaDB clusters, the ScyllaDB Operator only automates operations for a single datacenter.
Operations related to multiple datacenters may require manual intervention of a human operator.
Most notably, destroying one of the Kubernetes clusters or ScyllaDB datacenters is going to leave DN nodes behind in other datacenters, and their removal has to be carried out manually.
The main mechanism used to set up a manual multi-datacenter ScyllaDB cluster is a field in ScyllaCluster’s specification - `externalSeeds`.
### External seeds
The `externalSeeds` field in ScyllaCluster’s specification enables control over external seeds that are propagated to ScyllaDB binary as `--seed-provider-parameters seeds=`.
In this context, external should be understood as “external to the datacenter being specified by the API”.
The provided seeds are used by the nodes as initial points of contact, which allows them to discover the cluster ring topology when joining it.
Refer to [ScyllaDB Seed Nodes](https://opensource.docs.scylladb.com/stable/kb/seed-nodes.html) in ScyllaDB documentation for more information regarding the function of seed nodes in ScyllaDB.
For more details regarding the function and implementation of external seeds, refer to [the original enhancement proposal](https://github.com/scylladb/scylla-operator/tree/v1.11/enhancements/proposals/1304-external-seeds).
### Networking
Since this guide assumes interconnectivity over PodIPs of the Kubernetes clusters, you are going to configure the ScyllaDB cluster’s nodes to communicate over PodIPs.
This is enabled by a subset of `exposeOptions` specified in ScyllaCluster API, introduced in v1.11.
For this particular setup, define the ScyllaClusters as follows:
```yaml
apiVersion: scylla.scylladb.com/v1
kind: ScyllaCluster
spec:
exposeOptions:
nodeService:
type: Headless
broadcastOptions:
clients:
type: PodIP
nodes:
type: PodIP
```
However, other configuration options allow for the manual deployment of multi-datacenter ScyllaDB clusters in different network setups. For details, refer to [Exposing ScyllaClusters](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/configure-external-access.md) in ScyllaDB Operator documentation.
#### Deploy a multi-datacenter ScyllaDB Cluster
#### Using context
Let’s specify contexts for `kubectl` commands used throughout the guide.
To retrieve the context of your current cluster, run:
```shell
kubectl config current-context
```
Save the contexts of the two clusters, which you are going to deploy the datacenters in, as `CONTEXT_DC1` and `CONTEXT_DC2` environment variables correspondingly.
#### Deploy the first datacenter
First, run the below command to create a dedicated ‘scylla’ namespace:
```shell
kubectl --context="${CONTEXT_DC1}" create ns scylla
```
For this guide, let’s assume that your cluster is running in `us-east-1` region and the nodes dedicated to running ScyllaDB nodes are running in zones `us-east-1a`, `us-east-1b` and `us-east-1c` correspondingly. If that is not the case, adjust the manifest accordingly.
#### WARNING
To ensure high availability and fault tolerance in ScyllaDB, it is crucial to **spread your nodes across multiple racks or availability zones**. As a general rule of thumb, you should use **as many racks as your desired replication factor**.
For example, if your replication factor is `3`, deploy your nodes across **3 different racks or availability zones**. This minimizes the risk of data loss and ensures your cluster remains available even if an entire rack or zone fails.
Save the ScyllaCluster manifest in `dc1.yaml`:
```yaml
apiVersion: scylla.scylladb.com/v1
kind: ScyllaCluster
metadata:
name: scylla-cluster
namespace: scylla
spec:
agentVersion: 3.12.0
version: 2026.2.5
cpuset: true
automaticOrphanedNodeCleanup: true
exposeOptions:
broadcastOptions:
clients:
type: PodIP
nodes:
type: PodIP
nodeService:
type: Headless
datacenter:
name: us-east-1
racks:
- name: a
members: 1
storage:
storageClassName: scylladb-local-xfs
capacity: 1800G
agentResources:
requests:
cpu: 100m
memory: 250M
limits:
cpu: 100m
memory: 250M
resources:
requests:
cpu: 7
memory: 56G
limits:
cpu: 7
memory: 56G
placement:
podAntiAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
- topologyKey: kubernetes.io/hostname
labelSelector:
matchLabels:
app.kubernetes.io/name: scylla
scylla/cluster: scylla-cluster
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: topology.kubernetes.io/zone
operator: In
values:
- us-east-1a
- key: scylla.scylladb.com/node-type
operator: In
values:
- scylla
tolerations:
- effect: NoSchedule
key: scylla-operator.scylladb.com/dedicated
operator: Equal
value: scyllaclusters
- name: b
members: 1
storage:
storageClassName: scylladb-local-xfs
capacity: 1800G
agentResources:
requests:
cpu: 100m
memory: 250M
limits:
cpu: 100m
memory: 250M
resources:
requests:
cpu: 7
memory: 56G
limits:
cpu: 7
memory: 56G
placement:
podAntiAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
- topologyKey: kubernetes.io/hostname
labelSelector:
matchLabels:
app.kubernetes.io/name: scylla
scylla/cluster: scylla-cluster
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: topology.kubernetes.io/zone
operator: In
values:
- us-east-1b
- key: scylla.scylladb.com/node-type
operator: In
values:
- scylla
tolerations:
- effect: NoSchedule
key: scylla-operator.scylladb.com/dedicated
operator: Equal
value: scyllaclusters
- name: c
members: 1
storage:
storageClassName: scylladb-local-xfs
capacity: 1800G
agentResources:
requests:
cpu: 100m
memory: 250M
limits:
cpu: 100m
memory: 250M
resources:
requests:
cpu: 7
memory: 56G
limits:
cpu: 7
memory: 56G
placement:
podAntiAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
- topologyKey: kubernetes.io/hostname
labelSelector:
matchLabels:
app.kubernetes.io/name: scylla
scylla/cluster: scylla-cluster
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: topology.kubernetes.io/zone
operator: In
values:
- us-east-1c
- key: scylla.scylladb.com/node-type
operator: In
values:
- scylla
tolerations:
- effect: NoSchedule
key: scylla-operator.scylladb.com/dedicated
operator: Equal
value: scyllaclusters
```
Apply the manifest:
```shell
kubectl --context="${CONTEXT_DC1}" apply --server-side -f=dc1.yaml
```
Wait for the cluster to be fully rolled out:
```shell
kubectl --context="${CONTEXT_DC1}" -n=scylla wait --for='condition=Progressing=False' scyllaclusters.scylla.scylladb.com/scylla-cluster
```
```console
scyllacluster.scylla.scylladb.com/scylla-cluster condition met
```
```shell
kubectl --context="${CONTEXT_DC1}" -n=scylla wait --for='condition=Degraded=False' scyllaclusters.scylla.scylladb.com/scylla-cluster
```
```console
scyllacluster.scylla.scylladb.com/scylla-cluster condition met
```
```shell
kubectl --context="${CONTEXT_DC1}" -n=scylla wait --for='condition=Available=True' scyllaclusters.scylla.scylladb.com/scylla-cluster
```
```console
scyllacluster.scylla.scylladb.com/scylla-cluster condition met
```
You can now verify that all the nodes of your cluster are in UN state:
```shell
kubectl --context="${CONTEXT_DC1}" -n=scylla exec -it pod/scylla-cluster-us-east-1-a-0 -c=scylla -- nodetool status
```
The expected output should look similar to the below:
```console
Datacenter: us-east-1
=====================
Status=Up/Down
|/ State=Normal/Leaving/Joining/Moving
-- Address Load Tokens Owns Host ID Rack
UN 10.0.70.195 290 KB 256 ? 494277b9-121c-4af9-bd63-3d0a7b9305f7 c
UN 10.0.59.24 559 KB 256 ? a3a98e08-0dfd-4a25-a96a-c5ab2f47eb37 b
UN 10.0.19.237 107 KB 256 ? 64b6292a-327f-4128-852a-6004039f402e a
```
##### Retrieve PodIPs of ScyllaDB nodes for use as external seeds
#### WARNING
Due to the ephemeral nature of PodIPs, it is ill-advised to use them as seeds in production environments.
This is because there is a high likelihood that the Pods of your ScyllaDB clusters will change their IPs during the cluster’s lifecycle, and so the provided seeds will no longer point to the ScyllaDB nodes.
It is undesired, as the seeds provided on node’s startup may serve as fallback contact points when all of the node’s peers are unreachable.
In production environments, it is recommended that you use domain names or non-ephemeral IP addresses as external seeds.
PodIPs are being used in this example for the sheer simplicity of this setup.
Use the below commands and their expected outputs as a reference for retrieving the PodIPs used by the cluster for inter-node communication.
```shell
kubectl --context="${CONTEXT_DC1}" -n=scylla get pod/scylla-cluster-us-east-1-a-0 --template='{{ .status.podIP }}'
```
```console
10.0.19.237
```
```shell
kubectl --context="${CONTEXT_DC1}" -n=scylla get pod/scylla-cluster-us-east-1-b-0 --template='{{ .status.podIP }}'
```
```console
10.0.59.24
```
```shell
kubectl --context="${CONTEXT_DC1}" -n=scylla get pod/scylla-cluster-us-east-1-c-0 --template='{{ .status.podIP }}'
```
```console
10.0.70.195
```
You are going to utilize the retrieved addresses as seeds for the other datacenter.
#### Deploy the second datacenter
To deploy the second datacenter, you will follow similar steps.
First, create a dedicated ‘scylla’ namespace:
```shell
kubectl --context="${CONTEXT_DC2}" create ns scylla
```
Replace the values in `.spec.externalSeeds` of the below manifest with the Pod IP addresses that you retrieved earlier.
The provided values are going to serve as initial contact points for the joining nodes of the second datacenter.
For this guide, let’s assume that the second cluster is running in `us-east-2` region and the nodes dedicated for running ScyllaDB nodes are running in zones `us-east-2a`, `us-east-2b` and `us-east-2c` correspondingly. If that is not the case, adjust the manifest accordingly.
#### WARNING
To ensure high availability and fault tolerance in ScyllaDB, it is crucial to **spread your nodes across multiple racks or availability zones**. As a general rule of thumb, you should use **as many racks as your desired replication factor**.
For example, if your replication factor is `3`, deploy your nodes across **3 different racks or availability zones**. This minimizes the risk of data loss and ensures your cluster remains available even if an entire rack or zone fails.
Having configured it, save the manifest as `dc2.yaml`:
```yaml
apiVersion: scylla.scylladb.com/v1
kind: ScyllaCluster
metadata:
name: scylla-cluster
namespace: scylla
spec:
agentVersion: 3.12.0
version: 2026.2.5
cpuset: true
automaticOrphanedNodeCleanup: true
exposeOptions:
broadcastOptions:
clients:
type: PodIP
nodes:
type: PodIP
nodeService:
type: Headless
externalSeeds:
- 10.0.19.237
- 10.0.59.24
- 10.0.70.195
datacenter:
name: us-east-2
racks:
- name: a
members: 1
storage:
storageClassName: scylladb-local-xfs
capacity: 1800G
agentResources:
requests:
cpu: 100m
memory: 250M
limits:
cpu: 100m
memory: 250M
resources:
requests:
cpu: 7
memory: 56G
limits:
cpu: 7
memory: 56G
placement:
podAntiAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
- topologyKey: kubernetes.io/hostname
labelSelector:
matchLabels:
app.kubernetes.io/name: scylla
scylla/cluster: scylla-cluster
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: topology.kubernetes.io/zone
operator: In
values:
- us-east-2a
- key: scylla.scylladb.com/node-type
operator: In
values:
- scylla
tolerations:
- effect: NoSchedule
key: scylla-operator.scylladb.com/dedicated
operator: Equal
value: scyllaclusters
- name: b
members: 1
storage:
storageClassName: scylladb-local-xfs
capacity: 1800G
agentResources:
requests:
cpu: 100m
memory: 250M
limits:
cpu: 100m
memory: 250M
resources:
requests:
cpu: 7
memory: 56G
limits:
cpu: 7
memory: 56G
placement:
podAntiAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
- topologyKey: kubernetes.io/hostname
labelSelector:
matchLabels:
app.kubernetes.io/name: scylla
scylla/cluster: scylla-cluster
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: topology.kubernetes.io/zone
operator: In
values:
- us-east-2b
- key: scylla.scylladb.com/node-type
operator: In
values:
- scylla
tolerations:
- effect: NoSchedule
key: scylla-operator.scylladb.com/dedicated
operator: Equal
value: scyllaclusters
- name: c
members: 1
storage:
storageClassName: scylladb-local-xfs
capacity: 1800G
agentResources:
requests:
cpu: 100m
memory: 250M
limits:
cpu: 100m
memory: 250M
resources:
requests:
cpu: 7
memory: 56G
limits:
cpu: 7
memory: 56G
placement:
podAntiAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
- topologyKey: kubernetes.io/hostname
labelSelector:
matchLabels:
app.kubernetes.io/name: scylla
scylla/cluster: scylla-cluster
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: topology.kubernetes.io/zone
operator: In
values:
- us-east-2c
- key: scylla.scylladb.com/node-type
operator: In
values:
- scylla
tolerations:
- effect: NoSchedule
key: scylla-operator.scylladb.com/dedicated
operator: Equal
value: scyllaclusters
```
To apply the manifest, run:
```shell
kubectl --context="${CONTEXT_DC2}" -n=scylla apply --server-side -f=dc2.yaml
```
Wait for the second datacenter to roll out:
```shell
kubectl --context="${CONTEXT_DC2}" -n=scylla wait --for='condition=Progressing=False' scyllaclusters.scylla.scylladb.com/scylla-cluster
```
```console
scyllacluster.scylla.scylladb.com/scylla-cluster condition met
```
```shell
kubectl --context="${CONTEXT_DC2}" -n=scylla wait --for='condition=Degraded=False' scyllaclusters.scylla.scylladb.com/scylla-cluster
```
```console
scyllacluster.scylla.scylladb.com/scylla-cluster condition met
```
```shell
kubectl --context="${CONTEXT_DC2}" -n=scylla wait --for='condition=Available=True' scyllaclusters.scylla.scylladb.com/scylla-cluster
```
```console
scyllacluster.scylla.scylladb.com/scylla-cluster condition met
```
You can verify that the nodes have joined the existing cluster and that you are now running a multi-datacenter ScyllaDB cluster by running `nodetool status` with the below command:
```shell
kubectl --context="${CONTEXT_DC2}" -n=scylla exec -it pod/scylla-cluster-us-east-2-a-0 -c=scylla -- nodetool status
```
```console
Datacenter: us-east-1
=====================
Status=Up/Down
|/ State=Normal/Leaving/Joining/Moving
-- Address Load Tokens Owns Host ID Rack
UN 10.0.70.195 705 KB 256 ? 494277b9-121c-4af9-bd63-3d0a7b9305f7 c
UN 10.0.59.24 764 KB 256 ? a3a98e08-0dfd-4a25-a96a-c5ab2f47eb37 b
UN 10.0.19.237 634 KB 256 ? 64b6292a-327f-4128-852a-6004039f402e a
Datacenter: us-east-2
=====================
Status=Up/Down
|/ State=Normal/Leaving/Joining/Moving
-- Address Load Tokens Owns Host ID Rack
UN 172.16.39.209 336 KB 256 ? 7c30ea55-7a4f-4d93-86f7-c881772ebe62 b
UN 172.16.25.18 759 KB 256 ? 665dde7e-e420-4db3-8c54-ca71efd39b2e a
UN 172.16.87.27 503 KB 256 ? c19c89cb-e24c-4062-9df4-2aa90ab29a99 c
```
## ScyllaDB Manager
To integrate a multi-datacenter ScyllaDB cluster with ScyllaDB Manager, you must deploy the ScyllaDB Manager in only one datacenter.
In this example, let’s choose the Kubernetes cluster deployed in the first datacenter to host it.
To deploy ScyllaDB Manager, follow the steps described in [Deploying ScyllaDB Manager on a Kubernetes Cluster](https://operator.docs.scylladb.com/stable/deploy-scylladb/install-scylladb-manager.md)
in ScyllaDB Operator documentation.
In order to define the ScyllaDB Manager tasks, add them to the ScyllaCluster object deployed in the same Kubernetes cluster
in which your ScyllaDB Manager is running.
Every datacenter (represented by ScyllaCluster CR) is, by default, provisioned with a new, random ScyllaDB Manager Agent auth token.
To use ScyllaDB Manager with multiple datacenter (represented by ScyllaClusters), you have to make sure they all use the same token.
Extract it from the first datacenter with the below command:
```shell
kubectl --context="${CONTEXT_DC1}" -n=scylla get secrets/scylla-cluster-auth-token --template='{{ index .data "auth-token.yaml" }}' | base64 -d
```
```console
auth_token: 84qtsfvm98qzmps8s65zr2vtpb8rg4sdzcbg4pbmg2pfhxwpg952654gj86tzdljfqnsghndljm58mmhpmwfgpsvjx2kkmnns8bnblmgkbl9n8l9f64rs6tcvttm7kmf
```
Save the output, replace the token with your own, and patch the secret in the second datacenter with the below command:
```shell
kubectl --context="${CONTEXT_DC2}" -n=scylla patch secret/scylla-cluster-auth-token--type='json' -p='[{"op": "add", "path": "/stringData", "value": {"auth-token.yaml": "auth_token: 84qtsfvm98qzmps8s65zr2vtpb8rg4sdzcbg4pbmg2pfhxwpg952654gj86tzdljfqnsghndljm58mmhpmwfgpsvjx2kkmnns8bnblmgkbl9n8l9f64rs6tcvttm7kmf"}}]'
```
Execute a rolling restart of the nodes in DC2 to make sure they pick up the new token:
```shell
kubectl --context="${CONTEXT_DC2}" -n=scylla patch scyllacluster/scylla-cluster --type='merge' -p='{"spec": {"forceRedeploymentReason": "sync scylla-manager-agent token ('"$( date )"')"}}'
```
## ScyllaDBMonitoring
To monitor your cluster, deploy ScyllaDBMonitoring in every datacenter independently.
To deploy ScyllaDB Monitoring, follow the steps described in [ScyllaDB Monitoring setup](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-monitoring/setup.md) in ScyllaDB Operator documentation.
# deploy-your-first-cluster.md
# Deploy your first cluster
This page walks you through creating a ScyllaDB cluster using the `ScyllaCluster` resource. It starts with a minimal development cluster you can deploy in minutes, then covers production-grade configuration.
## Prerequisites
- ScyllaDB Operator installed.
Follow [Install with Helm](https://operator.docs.scylladb.com/stable/install-operator/install-with-helm.md), [Install with GitOps](https://operator.docs.scylladb.com/stable/install-operator/install-with-gitops.md), or [Install on OpenShift](https://operator.docs.scylladb.com/stable/install-operator/install-on-openshift.md) if you have not done so yet.
- Dedicated nodes labeled and tainted per [Set up dedicated node pools](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/set-up-dedicated-node-pools.md).
- Nodes configured with local disk setup and kernel tuning via `NodeConfig`, and the Local CSI Driver installed to provision `PersistentVolumes` from local storage.
Follow [Configure nodes](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/configure-nodes.md) if you have not done so yet.
- [`kubectl`](https://kubernetes.io/docs/tasks/tools/#kubectl) configured and pointed at the cluster.
## Quick path: create a development cluster
If you have ScyllaDB Operator installed and just want to get a ScyllaDB cluster running, follow these steps.
### Create a ScyllaDB configuration
Create a ConfigMap containing the `scylla.yaml` configuration. ScyllaDB Operator generates most ScyllaDB settings automatically (networking, listen addresses, seeds), but you can use this ConfigMap to fine-tune settings that ScyllaDB Operator does not manage:
```shell
kubectl apply --server-side -f=- <
- key: scylla.scylladb.com/node-type
operator: In
values:
- scylla
tolerations:
- key: scylla-operator.scylladb.com/dedicated
operator: Equal
value: scyllaclusters
effect: NoSchedule
```
Replace `` with the actual zone name for each rack (e.g., `us-east1-b`, `us-east-1a`).
## Next steps
- Learn how to [connect your application](https://operator.docs.scylladb.com/stable/connect-your-app/index.md) to ScyllaDB.
- Review the [production checklist](https://operator.docs.scylladb.com/stable/deploy-scylladb/production-checklist.md) before going to production.
- See the [reference deployments](https://operator.docs.scylladb.com/stable/deploy-scylladb/reference-deployments/index.md) for complete end-to-end examples on specific platforms.
# discovery.md
# Discovery endpoint
This page explains how ScyllaDB clusters are discoverable by clients on Kubernetes and how to expose the discovery endpoint beyond the cluster boundary.
## How discovery works
For every ScyllaCluster, the Operator creates a Kubernetes Service named `-client` that matches all ScyllaDB Pods in the cluster by label. Kubernetes routes traffic only to Pods that pass their readiness probe. This Service acts as a stable entry point: clients connect to it to reach any available ScyllaDB node, and from there the driver automatically discovers all other nodes in the cluster.
```shell
kubectl get scyllacluster/scylladb service/scylladb-client
```
```default
NAME READY MEMBERS RACKS AVAILABLE
scyllacluster.scylla.scylladb.com/scylladb 1 1 1 True
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S)
service/scylladb-client ClusterIP 10.102.44.43 7000/TCP,7001/TCP,9042/TCP,9142/TCP,19042/TCP,19142/TCP,7199/TCP,10001/TCP,9180/TCP,5090/TCP,9100/TCP,9160/TCP,8043/TCP
```
### Using the endpoint
You can reach the discovery endpoint by:
- **ClusterIP**: `kubectl get service/-client -o='jsonpath={.spec.clusterIP}'`
- **DNS name**: `-client..svc` (for in-cluster clients)
Clients should use this endpoint as their initial contact point. The driver connects to one of the ready nodes, fetches the cluster topology, and establishes connections to all nodes.
## Exposing beyond the Kubernetes cluster
If you need to connect from outside the Kubernetes cluster and are using Pod IPs as the broadcast address type, you can expose the discovery endpoint by creating a separate LoadBalancer Service that selects the same Pods. Do **not** patch the operator-managed `-client` Service directly — the operator reconciles it and will revert manual changes.
GKE
```yaml
apiVersion: v1
kind: Service
metadata:
name: -client-external
namespace: scylla
annotations:
networking.gke.io/load-balancer-type: Internal
spec:
type: LoadBalancer
selector:
scylla/cluster:
app: scylla
scylla-operator.scylladb.com/pod-type: scylladb-node
ports:
- name: cql
port: 9042
targetPort: 9042
- name: cql-ssl
port: 9142
targetPort: 9142
```
```shell
kubectl wait --for=jsonpath='{.status.loadBalancer.ingress}' service/-client-external -n scylla
kubectl get service/-client-external -n scylla -o='jsonpath={.status.loadBalancer.ingress[0].ip}'
```
EKS
```yaml
apiVersion: v1
kind: Service
metadata:
name: -client-external
namespace: scylla
annotations:
service.beta.kubernetes.io/aws-load-balancer-scheme: internal
service.beta.kubernetes.io/aws-load-balancer-backend-protocol: tcp
spec:
type: LoadBalancer
selector:
scylla/cluster:
app: scylla
scylla-operator.scylladb.com/pod-type: scylladb-node
ports:
- name: cql
port: 9042
targetPort: 9042
- name: cql-ssl
port: 9142
targetPort: 9142
```
```shell
kubectl wait --for=jsonpath='{.status.loadBalancer.ingress}' service/-client-external -n scylla
kubectl get service/-client-external -n scylla -o='jsonpath={.status.loadBalancer.ingress[0].hostname}'
```
## Related pages
- [Connect via CQL](https://operator.docs.scylladb.com/stable/connect-your-app/connect-via-cql.md) — using the discovery endpoint for CQL connections.
- [Configure external access](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/configure-external-access.md) — configuring expose options for external connectivity.
- [Networking architecture](https://operator.docs.scylladb.com/stable/understand/networking.md) — how Services and expose options work.
# expand-storage-volumes.md
# Expand storage volumes
Increase the persistent volume size of an existing ScyllaDB cluster when your data outgrows the initial storage allocation.
## Overview
Kubernetes StatefulSet `volumeClaimTemplates` are immutable — they cannot be updated in place.
Because the ScyllaDB Operator manages each rack as a StatefulSet, expanding storage requires an orphan-delete workflow:
you delete the controlling objects without deleting the underlying Pods or PVCs, patch the PVCs directly, then recreate the objects with the updated capacity.
The Operator does **not** automate volume expansion today — updating the storage capacity in the ScyllaCluster spec is rejected by webhook validation.
You must perform the manual procedure described below.
## Expand storage in a ScyllaCluster
The following example assumes a ScyllaCluster named `scylla` in the `scylla` namespace.
## Procedure overview
Kubernetes does not allow changing the `storageClassName` or reducing `storage.capacity` in a StatefulSet’s volume claim template. To expand storage, you must temporarily orphan the parent objects while keeping the Pods and PVCs running. The steps are:
1. Save the current ScyllaCluster definition
2. Orphan-delete the ScyllaCluster (preserves PVCs and Pods)
3. Orphan-delete the ScyllaDBDatacenter (internal resource — preserves StatefulSets)
4. Orphan-delete each StatefulSet (preserves Pods and PVCs)
5. Patch each PVC with the new storage size
6. Recreate the ScyllaCluster with the new storage size
7. Verify the expansion
### Step 1: Save the current ScyllaCluster definition
#### NOTE
The following commands use `yq`, a YAML command-line tool. Install it with:
```bash
# macOS
brew install yq
# Linux
wget -qO /usr/local/bin/yq https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 && chmod +x /usr/local/bin/yq
```
```bash
kubectl -n scylla get scyllacluster scylla -o yaml | yq 'del(
.metadata.creationTimestamp,
.metadata.generation,
.metadata.uid,
.metadata.resourceVersion,
.status
)' > scyllaClusterDefinition.yaml
```
### Step 2: Orphan-delete the ScyllaCluster
Delete the ScyllaCluster object while preserving all dependent resources (ScyllaDBDatacenter, StatefulSets, Pods, PVCs):
```bash
kubectl -n scylla delete scyllacluster/scylla --cascade='orphan'
```
### Step 3: Orphan-delete the ScyllaDBDatacenter
The ScyllaDBDatacenter has the same name as the ScyllaCluster:
```bash
kubectl -n scylla delete scylladbdatacenter/scylla --cascade='orphan'
```
### Step 4: Orphan-delete the StatefulSets
Delete the StatefulSets to decouple them from the immutable `volumeClaimTemplates`, while keeping the Pods running:
```bash
kubectl -n scylla delete statefulset --selector scylla/cluster=scylla --cascade='orphan'
```
### Step 5: Patch the PVCs
List the PVCs belonging to the cluster:
```bash
kubectl -n scylla get pvc --selector scylla/cluster=scylla
```
```default
NAME STATUS VOLUME CAPACITY ACCESS MODES STORAGECLASS AGE
data-scylla-us-east-1-a-0 Bound pvc-b96d6314-cd29-4f04-b86f-62a99634d62f 100Gi RWO scylladb-local-xfs 62m
data-scylla-us-east-1-a-1 Bound pvc-a13b1123-4f04-b86f-cd29-77b00534f63a 100Gi RWO scylladb-local-xfs 62m
data-scylla-us-east-1-a-2 Bound pvc-cd31cf0f-9daa-44c2-a0d9-8056780545cd 100Gi RWO scylladb-local-xfs 62m
```
For each PVC, patch it with the new desired size:
```bash
kubectl -n scylla patch pvc/data-scylla-us-east-1-a-0 -p '{"spec":{"resources":{"requests":{"storage":"300Gi"}}}}'
kubectl -n scylla patch pvc/data-scylla-us-east-1-a-1 -p '{"spec":{"resources":{"requests":{"storage":"300Gi"}}}}'
kubectl -n scylla patch pvc/data-scylla-us-east-1-a-2 -p '{"spec":{"resources":{"requests":{"storage":"300Gi"}}}}'
```
### Step 6: Update the ScyllaCluster definition and apply
Edit the saved definition to reflect the new storage capacity in `spec.datacenter.racks[*].storage.capacity`:
```yaml
spec:
datacenter:
racks:
- name: us-east-1a
storage:
capacity: 300Gi # updated from 100Gi
```
Apply the updated definition:
```bash
kubectl apply --server-side -f scyllaClusterDefinition.yaml
```
The Operator recreates the ScyllaDBDatacenter and StatefulSets with the new storage size.
The existing Pods are adopted by the new StatefulSets.
### Step 7: Verify the expansion
Depending on your storage provisioner, the expansion may happen online or require a Pod restart.
Verify the filesystem size from within each affected Pod:
```bash
kubectl -n scylla exec scylla-us-east-1-a-0 -c scylla -- df -h /var/lib/scylla
```
Repeat for all Pods in the cluster.
Check the PVC status to confirm the resize has completed:
```bash
kubectl -n scylla get pvc --selector scylla/cluster=scylla
```
The `CAPACITY` column should reflect the new size.
## Why the orphan-delete flow is necessary
The Operator represents each rack as a Kubernetes StatefulSet.
StatefulSet `volumeClaimTemplates` are [immutable by design](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/#stable-storage) in Kubernetes — once created, they cannot be changed.
Additionally, the Operator’s webhook validation rejects changes to the storage fields to prevent inconsistencies between the spec and the actual StatefulSet.
The orphan-delete strategy (`--cascade=orphan`) removes the parent objects (ScyllaCluster → ScyllaDBDatacenter → StatefulSet) without deleting their children (Pods, PVCs).
This lets you patch the PVCs directly and then recreate the parent objects with the updated capacity, so the new StatefulSet’s `volumeClaimTemplates` match the already-resized PVCs.
## Related pages
- [Scale, add, remove racks](https://operator.docs.scylladb.com/stable/operate/scale-add-remove-racks.md) — changing the number of nodes instead of the volume size
- [StatefulSets and racks](https://operator.docs.scylladb.com/stable/understand/statefulsets-and-racks.md) — why each rack maps to a StatefulSet and what constraints that implies
- [Replace nodes](https://operator.docs.scylladb.com/stable/operate/replace-nodes.md) — replacing a node with a fresh PVC rather than expanding the existing one
# exposing-grafana.md
# Expose Grafana
This guide shows how to expose Grafana deployed by `ScyllaDBMonitoring` using an `Ingress` resource.
#### NOTE
For accessing the Grafana service from outside the Kubernetes cluster we document using an `Ingress`, although there are other options like an `HTTPRoute` from the Gateway API.
Use whatever method fits your use case best.
## Prerequisites
This assumes that you have already deployed a `ScyllaDBMonitoring` in your cluster. If you haven’t done so, please follow the [ScyllaDB Monitoring setup](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-monitoring/setup.md) guide first.
In the example below we’re using the HAProxy Ingress Controller. You can deploy it in your Kubernetes cluster using the provided
third-party example. If you already have it (or another Ingress Controller) deployed in your cluster, you can skip the below steps.
### Install HAProxy Ingress
Deploy HAProxy Ingress using kubectl:
```shell
kubectl apply -n haproxy-ingress --server-side -f=https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/examples/third-party/haproxy-ingress.yaml
```
Wait for HAProxy Ingress to roll out:
```console
kubectl -n haproxy-ingress rollout status --timeout=5m deployments.apps/haproxy-ingress
```
## Expose Grafana using Ingress
ScyllaDB Operator creates a `ClusterIP` Service named `-grafana` for each `ScyllaDBMonitoring`.
Grafana serves TLS using a self-signed certificate that’s signed by a CA stored in a Secret named `-grafana-serving-ca` by default.
#### NOTE
You can use your own serving certificate by setting `ScyllaDBMonitoring`’s `spec.components.grafana.servingCertSecretName` field.
Create the following Ingress resource that will route requests with `test-grafana.test.svc.cluster.local` SNI to the Grafana:
```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: "example-grafana"
namespace: "scylla"
annotations:
haproxy.org/server-ssl: "true" # HA Proxy should use TLS when connecting to the backend.
haproxy.org/server-ca: "default/example-grafana-serving-ca" # HA Proxy should trust the Grafana serving certificate signed by this CA.
spec:
ingressClassName: haproxy
tls:
- hosts:
- "test-grafana.test.svc.cluster.local"
rules:
- host: "test-grafana.test.svc.cluster.local"
http:
paths:
- backend:
service:
name: "example-grafana"
port:
number: 3000
path: /
pathType: Prefix
```
You can apply the above manifest using `kubectl`:
```shell
kubectl apply -n scylla --server-side -f=https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/examples/monitoring/v1alpha1/grafana-haproxy.ingress.yaml
```
#### NOTE
In production, you should make sure that the Ingress controller properly terminates TLS using certificates issued by a trusted CA,
e.g. using [cert-manager](https://cert-manager.io/docs/) to automatically issue and renew certificates from Let’s Encrypt.
## Verify connection
### Get Grafana credentials
To access Grafana, you need to collect the credentials.
```console
GRAFANA_USER="$( kubectl -n scylla get secret/example-grafana-admin-credentials --template '{{ index .data "username" }}' | base64 -d )"
GRAFANA_PASSWORD="$( kubectl -n scylla get secret/example-grafana-admin-credentials --template '{{ index .data "password" }}' | base64 -d )"
```
### Get Ingress IP and port
If your cluster supports `LoadBalancer` services, your Ingress should be assigned an external IP address. You can get it by running:
```console
INGRESS_IP="$( kubectl -n haproxy-ingress get svc haproxy-ingress --template '{{ index .status.loadBalancer.ingress 0 "ip" }}' )"
INGRESS_PORT="443"
```
Otherwise, if you’re running this locally (e.g. using `minikube` or `kind`), you can port-forward the Ingress controller service to your local machine:
```console
kubectl -n haproxy-ingress port-forward svc/haproxy-ingress 8443:443 &
INGRESS_IP="127.0.0.1"
INGRESS_PORT="8443"
```
### Test connection
Now, you can verify the connection to the Grafana through the Ingress.
```console
curl --fail -s -o /dev/null -w '%{http_code}' -k \
--resolve "test-grafana.test.svc.cluster.local:${INGRESS_PORT}:${INGRESS_IP}" \
--user "${GRAFANA_USER}:${GRAFANA_PASSWORD}" \
"https://test-grafana.test.svc.cluster.local:${INGRESS_PORT}/"
```
You should see `200` as the output, indicating a successful connection.
# external-prometheus-on-openshift.md
# Set up ScyllaDB Monitoring on OpenShift
This guide will walk you through setting up a monitoring stack for your ScyllaDB clusters using the
[`ScyllaDBMonitoring`](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/scylladbmonitorings.md) custom resource and an
external Prometheus instance that is already deployed in your Kubernetes cluster in an OpenShift cluster using [User Workload Monitoring (UWM)](https://docs.redhat.com/en/documentation/openshift_container_platform/4.20/html/monitoring/configuring-user-workload-monitoring).
The guide assumes you have read the [overview](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-monitoring/index.md) and [setup](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-monitoring/setup.md) of ScyllaDB monitoring and are familiar with the concepts of Prometheus and Grafana.
## Requirements
This guide assumes you have ScyllaDB Operator and a `ScyllaCluster` already installed in your OpenShift cluster.
For more information on how to deploy ScyllaDB Operator, see [the installation guide](https://operator.docs.scylladb.com/stable/install-operator/index.md).
#### NOTE
The ScyllaDB Operator installation process on OpenShift is the same as on vanilla Kubernetes. However, unlike Kubernetes,
OpenShift includes a built-in Prometheus Operator and [User Workload Monitoring (UWM)](https://docs.redhat.com/en/documentation/openshift_container_platform/4.20/html/monitoring/configuring-user-workload-monitoring) for user
workloads. Therefore, instead of deploying Prometheus using ScyllaDBMonitoring, we configure it to use the external
Prometheus instance provided by OpenShift UWM.
We also assume you have the `oc` CLI tool installed and configured to access your OpenShift cluster, and have the necessary
permissions to create `ServiceAccounts` and `ClusterRoleBindings`.
## Enable User Workload Monitoring in OpenShift
OpenShift provides a built-in Prometheus instance that can be used for monitoring user workloads.
To use this Prometheus instance, you need to enable User Workload Monitoring in your OpenShift cluster.
You can do this by following the [official OpenShift documentation](https://docs.redhat.com/en/documentation/openshift_container_platform/4.20/html/monitoring/configuring-user-workload-monitoring).
## Configure OpenShift metrics access for Grafana datasource
### Create ServiceAccount and ClusterRoleBinding
To allow `ScyllaDBMonitoring`-managed Grafana to access the OpenShift User Workload Monitoring Prometheus instance,
you need to create a `ServiceAccount` and a `ClusterRoleBinding` that grants the necessary permissions. We will use its
`ServiceAccount` token for configuring Grafana datasource. See the OpenShift’s [Accessing metrics as a developer](https://docs.redhat.com/en/documentation/monitoring_stack_for_red_hat_openshift/4.20/html/accessing_metrics/accessing-metrics-as-a-developer)
article for more details.
#### NOTE
We assume you have `ScyllaCluster` deployed in `scylla` namespace/project. Replace `scylla` with your namespace/project name if it’s different.
You can create the `ServiceAccount` and `ClusterRoleBinding` using the following commands:
```shell
oc create -n=scylla serviceaccount scylla-grafana-monitoring-viewer
oc create clusterrolebinding scylla-monitoring-grafana-cluster-monitoring-view --clusterrole=cluster-monitoring-view --serviceaccount=scylla:scylla-grafana-monitoring-viewer
```
### Create ServiceAccount token Secret
Next, you need to create a `Secret` that contains the `ServiceAccount` token. The following manifest will create such a `Secret`:
```yaml
apiVersion: v1
kind: Secret
metadata:
name: scylla-monitoring-grafana-token
namespace: scylla
annotations:
kubernetes.io/service-account.name: scylla-grafana-monitoring-viewer
type: kubernetes.io/service-account-token
```
You can create it using the following command:
```shell
kubectl apply -n scylla -f https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/examples/monitoring/v1alpha1/openshift/sa-token.secret.yaml
```
The `Secret` will be populated with the token automatically by Kubernetes and should be available under the `token` key of this `Secret`. Verify it by running:
```shell
kubectl -n scylla get secret scylla-monitoring-grafana-token -o=jsonpath='{.data.token}'
```
You should see the encoded token printed to the console.
## Create service CA certificate ConfigMap
OpenShift uses a self-signed CA to sign the certificates for its internal services. To allow Grafana to trust the OpenShift UWM Prometheus instance,
you need to create a `ConfigMap` that, when properly annotated, will be populated with the OpenShift service CA certificate.
Please refer to the [OpenShift documentation](https://docs.redhat.com/en/documentation/openshift_container_platform/4.20/html/security_and_compliance/certificate-types-and-descriptions#cert-types-service-ca-certificates)
for more details on this mechanism.
The following manifest will create such a `ConfigMap`:
```yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: example-openshift-service-ca
annotations:
"service.beta.openshift.io/inject-cabundle": "true"
```
You can create it using the following command:
```shell
kubectl apply -n scylla -f https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/examples/monitoring/v1alpha1/openshift/service-ca.configmap.yaml
```
You can verify that the `ConfigMap` has been populated with the service CA certificate under the `service-ca.crt` key by running:
```shell
kubectl -n scylla get configmap example-openshift-service-ca -o=jsonpath='{.data.service-ca\.crt}'
```
You should see the PEM-encoded CA certificate printed to the console.
## Deploy ScyllaDBMonitoring
The following `ScyllaDBMonitoring` configuration will set up the monitoring stack to use the OpenShift UWM Prometheus instance
as an external Prometheus datasource for Grafana:
```yaml
apiVersion: scylla.scylladb.com/v1alpha1
kind: ScyllaDBMonitoring
metadata:
name: example
namespace: scylla
spec:
type: Platform
endpointsSelector:
matchLabels:
app.kubernetes.io/name: scylla
scylla-operator.scylladb.com/scylla-service-type: member
scylla/cluster: scylla
components:
prometheus:
mode: External
grafana:
datasources:
# Prometheus datasource pointing to OpenShift's Thanos Querier service.
# To make this work, `cluster-monitoring-config` ConfigMap in `openshift-monitoring` namespace must be configured
# to contain `config.yaml` key with `enableUserWorkload: true` in its content.
# See https://docs.redhat.com/en/documentation/openshift_container_platform/4.19/html/monitoring/configuring-user-workload-monitoring#enabling-monitoring-for-user-defined-projects_preparing-to-configure-the-monitoring-stack-uwm for details.
- type: Prometheus
url: "https://thanos-querier.openshift-monitoring.svc:9091"
prometheusOptions:
tls:
caCertConfigMapRef:
# This is the ConfigMap reference for OpenShift's injected Service CA bundle.
name: example-openshift-service-ca
key: service-ca.crt
auth:
type: BearerToken
bearerTokenOptions:
secretRef:
# This is a `kubernetes.io/service-account-token` type of Secret created for a ServiceAccount bound to
# `cluster-monitoring-view` ClusterRole.
name: scylla-monitoring-grafana-token
key: token
```
You can apply it using `kubectl`:
```shell
kubectl apply -n scylla --server-side -f=https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/examples/monitoring/v1alpha1/openshift/uwm.scylladbmonitoring.yaml
```
See the [Setting up ScyllaDBMonitoring](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-monitoring/setup.md#deploy-scylladbmonitoring) guide for more details on deploying `ScyllaDBMonitoring`.
## Verify the setup
You can verify that configuration is correct by [accessing Grafana](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-monitoring/exposing-grafana.md) and verifying you can see metrics from your ScyllaDB cluster.
# feature-gates.md
# Feature gates
ScyllaDB Operator lets you enable or disable features using feature gates.
This page lists the available feature gates and explains how to configure them.
## Configuring feature gates
Feature gates are set with the `--feature-gates` command-line argument of ScyllaDB Operator.
The value is a comma-separated list of `=` pairs.
For example, to enable both gates:
```default
--feature-gates=AutomaticTLSCertificates=true,BootstrapSynchronisation=true
```
GitOps (kubectl)
Modify the ScyllaDB Operator Deployment and add the `--feature-gates` argument to the container args:
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: scylla-operator
namespace: scylla-operator
spec:
template:
spec:
containers:
- name: scylla-operator
args:
- operator
- --feature-gates=AutomaticTLSCertificates=true,BootstrapSynchronisation=true
```
Helm
Add the `--feature-gates` argument through the `additionalArgs` value in `values.yaml`:
```yaml
additionalArgs:
- --feature-gates=AutomaticTLSCertificates=true,BootstrapSynchronisation=true
```
## Available feature gates
| Feature gate | Default | Last changed |
|----------------------------|-----------|----------------|
| `AutomaticTLSCertificates` | `true` | v1.11 |
| `BootstrapSynchronisation` | `false` | v1.19 |
- **Default** — whether the feature is enabled when you don’t set it explicitly.
- **Last changed** — the Operator version in which the feature gate was introduced or its default was changed.
### AutomaticTLSCertificates
Enables automated TLS certificate provisioning for ScyllaDB clusters.
When enabled, the Operator generates and rotates serving and client TLS certificates and configures ScyllaDB nodes to use them for encrypted client-to-node CQL communication (mTLS).
Client certificates are validated by ScyllaDB nodes (the certificate chain must be trusted), but ScyllaDB does **not** perform client identity or authorization checks based on certificate contents.
See [Security — ScyllaDB cluster TLS](https://operator.docs.scylladb.com/stable/understand/security.md) for the full certificate architecture, and [Connect via CQL](https://operator.docs.scylladb.com/stable/connect-your-app/connect-via-cql.md) for client configuration.
### BootstrapSynchronisation
Automates ensuring that no nodes are down when a new ScyllaDB node bootstraps.
The Operator verifies the status of all existing nodes in the cluster and blocks the new node’s startup until every node is confirmed healthy.
See [Bootstrap synchronisation](https://operator.docs.scylladb.com/stable/understand/bootstrap-sync.md) for details on the mechanism.
# get-started.md
# Getting started with IPv6 networking
This tutorial teaches you how to deploy your first ScyllaDB cluster with IPv6 networking. You’ll learn IPv6 networking concepts while setting up a working cluster.
## What you’ll learn
In this tutorial, you’ll:
- Understand what IPv6 networking means for ScyllaDB
- Verify your Kubernetes cluster supports IPv6
- Deploy a ScyllaDB cluster with dual-stack networking
- Verify your cluster is working correctly
- Understand the configuration you created
#### NOTE
This tutorial uses **dual-stack** configuration (both IPv4 and IPv6) because it’s production-ready and well-tested. IPv6-only configurations are experimental. See [Production readiness](https://operator.docs.scylladb.com/stable/reference/ipv6-configuration.md#production-readiness) for details.
## Prerequisites
Before you begin:
### Kubernetes cluster
- **Dual-stack support**: Your cluster needs both IPv4 and IPv6 network ranges configured
### ScyllaDB
- **ScyllaDB version**: 2024.1 or newer (recommended for IPv6 support)
- **ScyllaDB Operator**: Already installed in your cluster
### Tools
- `kubectl` configured to access your cluster
- Basic familiarity with ScyllaDB and Kubernetes concepts
## Step 1: Verify IPv6 support
Check if your cluster has at least one node that has an IPv6 address of type InternalIP:
```bash
kubectl get nodes -o jsonpath='{.items[*].status.addresses[?(@.type=="InternalIP")].address}' | tr ' ' '\n' | grep ':'
```
This command filters for IPv6 addresses. You can quickly tell if an IP address is IPv4 if it uses dots `.` as separators (e.g. 172.16.57.29); IPv6 addresses use colons `:` as separators (e.g. 2001:db8:1::1).
**Example output for an IPv6-ready cluster:**
```default
2001:db8:1::1
2001:db8:1::2
2001:db8:1::3
```
If you see IPv6 addresses in the output, then your cluster has some IPv6-enabled nodes.
## Step 2: Understand dual-stack networking
Before deploying, let’s understand what dual-stack means:
- **Kubernetes services**: Have both IPv4 and IPv6 addresses
- **ScyllaDB nodes**: Communicate using a single IP family (IPv4 in this tutorial)
- **Client connectivity**: Clients can discover services via either protocol
This is useful when you have clients on different network types that all need to access your database.
## Step 3: Create your first IPv6-enabled cluster
Download the example dual-stack configuration:
```shell
kubectl apply -f=https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/examples/ipv6/scylla-cluster-minimal-dual-stack.yaml
```
You can view the complete example configuration in the repository: [scylla-cluster-minimal-dual-stack.yaml](https://operator.docs.scylladb.com/stable/../../examples/ipv6/scylla-cluster-minimal-dual-stack.yaml)
The key networking configuration is:
```yaml
network:
ipFamilyPolicy: PreferDualStack
ipFamilies:
- IPv4 # ScyllaDB will use IPv4 internally
- IPv6 # Services will also be accessible via IPv6
dnsPolicy: ClusterFirst
```
Or deploy directly:
```shell
kubectl create namespace scylla
kubectl apply -f=https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/examples/ipv6/scylla-cluster-minimal-dual-stack.yaml
```
## Step 4: Watch the cluster deploy
Monitor the cluster deployment:
```bash
kubectl get pods -n scylla -w
```
Wait until all pods show `Running` status with `4/4` ready:
```default
NAME READY STATUS RESTARTS AGE IP NODE
scylla-ipv6-tutorial-us-east-1-us-east-1a-0 4/4 Running 0 5m 10.244.1.5 worker-1
scylla-ipv6-tutorial-us-east-1-us-east-1a-1 4/4 Running 0 4m 10.244.2.6 worker-2
scylla-ipv6-tutorial-us-east-1-us-east-1a-2 4/4 Running 0 3m 10.244.3.7 worker-3
```
## Step 5: Verify IPv6 configuration
Check that your services have both IPv4 and IPv6 addresses:
```bash
kubectl get svc -n scylla -o custom-columns=NAME:.metadata.name,IP-FAMILIES:.spec.ipFamilies,POLICY:.spec.ipFamilyPolicy
```
**Expected output:**
```default
NAME IP-FAMILIES POLICY
scylla-ipv6-tutorial-client [IPv4 IPv6] PreferDualStack
scylla-ipv6-tutorial-tutorial-dc-tutorial-rack-0 [IPv4 IPv6] PreferDualStack
scylla-ipv6-tutorial-tutorial-dc-tutorial-rack-1 [IPv4 IPv6] PreferDualStack
scylla-ipv6-tutorial-tutorial-dc-tutorial-rack-2 [IPv4 IPv6] PreferDualStack
```
The `IP-FAMILIES` column shows both IPv4 and IPv6, confirming dual-stack configuration.
## Step 6: Verify cluster health
Check the cluster status using nodetool:
```bash
kubectl exec -it scylla-ipv6-tutorial-tutorial-dc-tutorial-rack-0 -n scylla -c scylla -- nodetool status
```
**Expected output:**
```default
Datacenter: tutorial-dc
=======================
Status=Up/Down
|/ State=Normal/Leaving/Joining/Moving
-- Address Load Tokens Owns Host ID Rack
UN 10.244.1.5 256 KB 256 ? a1b2c3d4-... tutorial-rack
UN 10.244.2.6 256 KB 256 ? e5f6g7h8-... tutorial-rack
UN 10.244.3.7 256 KB 256 ? i9j0k1l2-... tutorial-rack
```
All nodes should have status `UN` (Up/Normal).
## Step 7: Test client connectivity
Let’s test connecting to the cluster via both IPv4 and IPv6:
```bash
# Get the client service IP addresses
kubectl get svc scylla-ipv6-tutorial-client -n scylla -o jsonpath='{.spec.clusterIPs}' | jq .
```
**Example output:**
```default
[
"10.96.10.20", # IPv4 address
"fd00:10:96::1234" # IPv6 address
]
```
Test connectivity with cqlsh:
```bash
kubectl run -it --rm cqlsh --image=scylladb/scylla-cqlsh:latest --restart=Never -n scylla-test -- \
scylla-ipv6-tutorial-client.scylla.svc.cluster.local 9042 \
-e "SELECT cluster_name,broadcast_address FROM system.local;"
```
**Example output**
```default
-------------------+---------------------
cluster_name | tutorial
broadcast_address | 10.96.136.225
(1 rows)
pod "cqlsh" deleted
```
## Understanding your configuration
Let’s break down what you configured:
### Network settings
```yaml
network:
ipFamilyPolicy: PreferDualStack # Use dual-stack if available
ipFamilies:
- IPv4 # First = ScyllaDB's internal protocol
- IPv6 # Second = Additional service accessibility
dnsPolicy: ClusterFirst # Essential for proper DNS resolution
```
**Key points:**
- The **first** IP family (`IPv4`) determines what protocol ScyllaDB uses internally
- The **second** IP family (`IPv6`) makes services accessible via IPv6 too
- `PreferDualStack` falls back to single-stack if dual-stack isn’t available
## What’s next?
Now that you have a working IPv6-enabled cluster, you can:
- Learn how to [configure different IPv6 setups](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/configure-dual-stack.md) (IPv6-only, different dual-stack configurations)
- Understand [how IPv6 networking works](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/ipv6-concepts.md) in ScyllaDB
- Explore the [IPv6 configuration reference](https://operator.docs.scylladb.com/stable/reference/ipv6-configuration.md) for all available options
- Learn how to [migrate existing clusters to IPv6](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/migration.md)
## Clean up
To remove the tutorial cluster:
```bash
kubectl delete -f scylla-cluster-ipv6.yaml
kubectl delete namespace scylla
```
## Related documentation
- [How to configure IPv6 networking](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/configure-dual-stack.md)
- [IPv6 networking concepts](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/ipv6-concepts.md)
- [IPv6 configuration reference](https://operator.docs.scylladb.com/stable/reference/ipv6-configuration.md)
# ignition.md
# Ignition
This page explains the ignition mechanism that gates ScyllaDB startup until all prerequisites are satisfied.
## Why ignition exists
ScyllaDB must not start until:
- **Node-level tuning is complete** — performance settings (IRQ affinity, sysctl values, CPU frequency governors) must be applied before ScyllaDB begins benchmarking IO or pinning threads. Starting too early produces incorrect IO calibration and suboptimal performance.
- **Network identity is assigned** — the pod must have an IP address, and if LoadBalancer broadcasting is used, the load balancer must have provisioned an ingress address.
- **The container is ready** — the ScyllaDB container must be running (container ID assigned) so that per-container tuning can target it.
Without ignition gating, the ScyllaDB process could start before tuning DaemonSets finish their work or before the cloud provider assigns a load balancer IP, leading to misconfiguration that is difficult to correct without a restart.
## Signal-file mechanism
Ignition uses a simple file-based signal on the shared emptyDir volume mounted at `/mnt/shared`:
1. The `scylladb-ignition` sidecar container runs the ignition controller, which continuously evaluates prerequisites.
2. When **all** prerequisites are met, the controller creates the file `/mnt/shared/ignition.done`.
3. The `scylla` container’s entrypoint polls for this file in a shell loop. Once the file appears, it execs into the sidecar binary that configures and starts ScyllaDB.
4. The ScyllaDB Manager Agent container (when present) uses the same wait loop for ignition, and additionally polls the ScyllaDB REST API (port 10000) to wait for ScyllaDB to finish IO tuning and become available before starting.
## Prerequisites evaluated
The ignition controller checks the following conditions. **All** must be true before the signal file is created:
| # | Condition | Why |
|-----|-------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 | **LoadBalancer ingress available** (only when broadcast address type is `ServiceLoadBalancerIngress`) | The broadcast address cannot be resolved until the cloud provider assigns an external IP or hostname to the member Service. |
| 2 | **Pod has an IP** (`status.podIP` is set) | ScyllaDB needs a listen address. The sidecar cannot resolve `PodIP`-type broadcast addresses without it. |
| 3 | **ScyllaDB container has a container ID** (`containerStatuses[].containerID` is set) | Per-container tuning (CPU pinning, cgroup settings) targets a specific container ID. Tuning cannot complete until the container exists. |
| 4 | **Tuning ConfigMap exists** with matching container ID | A ConfigMap labeled for this pod must exist, created by the tuning infrastructure. Its `ContainerID` field must match the current ScyllaDB container ID, confirming that tuning ran for this specific container instance. |
| 5 | **No blocking NodeConfigs** in the tuning ConfigMap | The ConfigMap must report that all `NodeConfig` resources have completed tuning. If any are still in progress, ignition waits. |
## Cleanup on shutdown
The `scylla` container’s `preStop` hook removes the signal file:
```default
rm -f /mnt/shared/ignition.done
```
This ensures that if the container restarts (due to a crash or rolling update), the ignition controller must re-evaluate all prerequisites before ScyllaDB starts again. This is important because a container restart assigns a new container ID, invalidating previous tuning results.
## Force override
For debugging or recovery scenarios, the annotation `internal.scylla-operator.scylladb.com/force-ignition-value` on the node’s member Service can override the ignition decision:
| Value | Effect |
|-----------|----------------------------------------------------------------------|
| `"true"` | Ignition proceeds immediately, bypassing all prerequisite checks. |
| `"false"` | Ignition is blocked indefinitely, regardless of prerequisite status. |
## Readiness probe
The ignition container exposes a readiness endpoint at `/readyz` on port 42081. It returns HTTP 200 only after the signal file has been created. This allows external tools and monitoring to determine whether a pod has passed the ignition gate.
## Related pages
- [Sidecar and pod anatomy](https://operator.docs.scylladb.com/stable/understand/sidecar.md) — the full container list and how they coordinate.
- [Tuning](https://operator.docs.scylladb.com/stable/understand/tuning.md) — the node and container tuning that must complete before ignition.
- [Bootstrap synchronisation](https://operator.docs.scylladb.com/stable/understand/bootstrap-sync.md) — the init container barrier that runs before ignition.
- [Security](https://operator.docs.scylladb.com/stable/understand/security.md) — TLS certificate provisioning that feeds into ignition prerequisites.
# install-on-openshift.md
# Install on OpenShift
This page walks you through installing ScyllaDB Operator and all its dependencies on Red Hat OpenShift using the Operator Lifecycle Manager (OLM) software catalog. If you are running on a generic Kubernetes distribution, see [Install with GitOps](https://operator.docs.scylladb.com/stable/install-operator/install-with-gitops.md) or [Install with Helm](https://operator.docs.scylladb.com/stable/install-operator/install-with-helm.md) instead.
ScyllaDB Operator is a Red Hat OpenShift Certified Operator. It is available in the embedded software catalog and can be installed through the OpenShift web console or CLI.
#### NOTE
**ScyllaDB Operator must run in the `scylla-operator` namespace** and **ScyllaDB Manager must run in the `scylla-manager` namespace**. Using different namespaces for these components is [not currently supported](https://github.com/scylladb/scylla-operator/issues/2563).
## Prerequisites
- An OpenShift Container Platform cluster meeting the [infrastructure requirements](https://operator.docs.scylladb.com/stable/install-operator/provision-infrastructure/index.md).
- An account with `cluster-admin` permissions.
- [`kubectl`](https://kubernetes.io/docs/tasks/tools/#kubectl) or [OpenShift CLI (`oc`)](https://docs.redhat.com/en/documentation/openshift_container_platform/4.20/html/cli_tools/openshift-cli-oc) configured to communicate with the cluster.
## Install ScyllaDB Operator
ScyllaDB Operator can be installed from the OpenShift software catalog using either the web console or the CLI.
Web Console
This procedure follows the generic Operator installation steps outlined in the upstream documentation: [Installing from the software catalog by using the web console](https://docs.redhat.com/en/documentation/openshift_container_platform/4.20/html/operators/administrator-tasks#olm-installing-from-software-catalog-using-web-console_olm-adding-operators-to-a-cluster).
### Procedure
1. Navigate to **Ecosystem** → **Software Catalog**.
2. Search for **ScyllaDB Operator** and select the **Certified** version by setting the **Source** filter to **Certified**, or by verifying that the ScyllaDB Operator tile has the **Certified** tag.
3. Read the description and click **Install**.
4. In the **Install Operator** dialog, configure the installation:
- For clusters on AWS with Security Token Service (STS): enter the Amazon Resource Name (ARN) of the AWS IAM role for your service account in the role ARN field.
- Select the **stable** Update Channel.
- Select the **All namespaces on the cluster** installation mode.
- Select the Operator recommended installed namespace: **scylla-operator**.
- Select the **Manual** update approval strategy to manually approve ScyllaDB Operator upgrades when new versions are available.
5. Click **Install**.
6. In the **Install Plan** dialog, review the manual install plan and click **Approve**.
7. Log in to the OpenShift cluster in the terminal. Ensure that `kubectl` is configured to communicate with your cluster.
CLI
This procedure follows the generic Operator installation steps outlined in the upstream documentation: [Installing from the software catalog by using the CLI](https://docs.redhat.com/en/documentation/openshift_container_platform/4.20/html/operators/administrator-tasks#olm-installing-operator-from-software-catalog-using-cli_olm-adding-operators-to-a-cluster).
### Procedure
1. Log in to the OpenShift cluster in the terminal. Ensure that `kubectl` is configured to communicate with your cluster.
2. Verify that the ScyllaDB Operator package is available:
```shell
kubectl get -n=openshift-marketplace packagemanifest scylladb-operator
```
**Expected output:**
```console
NAME CATALOG AGE
scylladb-operator Certified Operators 2d22h
```
3. Create the `scylla-operator` namespace:
```shell
kubectl create namespace scylla-operator
```
4. Create an `OperatorGroup` in the `scylla-operator` namespace:
```shell
kubectl apply --server-side -n=scylla-operator -f=- <"
EOF
```
Replace `` with the ARN of the AWS IAM role for your service account.
Generic
```shell
kubectl apply --server-side -n=scylla-operator -f=- <
```
Approve it to start the installation:
```shell
kubectl -n=scylla-operator patch installplan --type=merge -p='{"spec":{"approved":true}}'
```
**Example expected output:**
```console
installplan.operators.coreos.com/install-tw6bv patched
```
7. Wait for the `ClusterServiceVersion` to reach `Succeeded` phase:
```shell
kubectl -n=scylla-operator wait --for=create --timeout=10m csv/scylladb-operator.v1.22.0
kubectl -n=scylla-operator wait --timeout=5m --for=jsonpath='{.status.phase}'=Succeeded clusterserviceversions.operators.coreos.com/scylladb-operator.v1.22.0
```
**Expected output:**
```console
clusterserviceversion.operators.coreos.com/scylladb-operator.v1.22.0 condition met
clusterserviceversion.operators.coreos.com/scylladb-operator.v1.22.0 condition met
```
### Verify the installation
Wait for CRDs to propagate to all API servers:
```shell
kubectl wait --for='condition=established' --timeout=60s \
crd/scyllaclusters.scylla.scylladb.com \
crd/nodeconfigs.scylla.scylladb.com \
crd/scyllaoperatorconfigs.scylla.scylladb.com \
crd/scylladbmonitorings.scylla.scylladb.com
```
**Expected output:**
```console
customresourcedefinition.apiextensions.k8s.io/scyllaclusters.scylla.scylladb.com condition met
customresourcedefinition.apiextensions.k8s.io/nodeconfigs.scylla.scylladb.com condition met
customresourcedefinition.apiextensions.k8s.io/scyllaoperatorconfigs.scylla.scylladb.com condition met
customresourcedefinition.apiextensions.k8s.io/scylladbmonitorings.scylla.scylladb.com condition met
```
Wait for ScyllaDB Operator and webhook server Deployments:
```shell
kubectl -n=scylla-operator rollout status --timeout=10m deployment.apps/scylla-operator
kubectl -n=scylla-operator rollout status --timeout=10m deployment.apps/webhook-server
```
**Expected output:**
```console
deployment "scylla-operator" successfully rolled out
deployment "webhook-server" successfully rolled out
```
## Next steps
- [Deploy ScyllaDB](https://operator.docs.scylladb.com/stable/deploy-scylladb/index.md) — choose a platform-specific reference deployment or deploy your first cluster.
## Related pages
- [Install with GitOps](https://operator.docs.scylladb.com/stable/install-operator/install-with-gitops.md) — alternative installation path using manifests (generic Kubernetes).
- [Install with Helm](https://operator.docs.scylladb.com/stable/install-operator/install-with-helm.md) — alternative installation path using Helm charts.
- [Upgrade ScyllaDB Operator](https://operator.docs.scylladb.com/stable/upgrade/upgrade-operator.md) — version-specific upgrade steps.
# install-scylladb-manager.md
# Install ScyllaDB Manager
[ScyllaDB Manager](https://manager.docs.scylladb.com/) provides automated repair and backup scheduling for ScyllaDB clusters.
With Manager installed, ScyllaDB Operator can:
- **Schedule backups** — automatically snapshot your data and upload it to object storage.
- **Schedule repairs** — run automated anti-entropy repairs to keep data consistent across replicas.
- **Restore from backup** — recover a ScyllaDB cluster from a previously created backup snapshot.
See [Restore from backup](https://operator.docs.scylladb.com/stable/operate/restore-from-backup.md).
For details on how Manager integrates with the Operator, see [ScyllaDB Manager](https://operator.docs.scylladb.com/stable/understand/manager.md).
## Prerequisites
- ScyllaDB Operator installed and running.
See [Install with Helm](https://operator.docs.scylladb.com/stable/install-operator/install-with-helm.md) or [Install with GitOps](https://operator.docs.scylladb.com/stable/install-operator/install-with-gitops.md).
- Nodes configured with the local CSI driver installed.
Manager deploys a small internal ScyllaCluster that uses the storage class provided by the local CSI driver.
See [Configure nodes](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/configure-nodes.md).
## Install ScyllaDB Manager
ScyllaDB Manager deploys into the `scylla-manager` namespace.
It runs a small internal ScyllaCluster for its own state.
#### NOTE
ScyllaDB Manager must be installed in the `scylla-manager` namespace.
The Operator expects Manager in this namespace and will not discover it otherwise.
GitOps (manifests)
Apply the manifest:
```shell
kubectl -n=scylla-manager apply --server-side -f=https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/deploy/manager-prod.yaml
```
Helm
Install the Helm chart:
```shell
helm install scylla-manager scylla/scylla-manager \
--create-namespace \
--namespace scylla-manager
```
Wait for Manager to become available:
```shell
kubectl -n=scylla-manager rollout status --timeout=10m deployment.apps/scylla-manager
```
## Verify the installation
Check that the Manager Pod is running:
```shell
kubectl -n=scylla-manager get pods
```
You should see the `scylla-manager` Deployment Pod and one or more Pods for the internal Manager ScyllaCluster.
## Next steps
- [ScyllaDB Manager](https://operator.docs.scylladb.com/stable/understand/manager.md) — understand Manager architecture, task synchronization, and security.
# install-with-gitops.md
# Install with GitOps
Install ScyllaDB Operator and its dependencies by applying raw manifests from the project repository.
This method works with any GitOps tool (Argo CD, Flux, etc.) or plain `kubectl apply`.
#### NOTE
ScyllaDB Operator must run in the `scylla-operator` namespace.
## Prerequisites
- A Kubernetes cluster meeting the [infrastructure requirements](https://operator.docs.scylladb.com/stable/install-operator/provision-infrastructure/index.md).
- [`kubectl`](https://kubernetes.io/docs/tasks/tools/#kubectl) configured to communicate with the cluster.
## Install cert-manager
ScyllaDB Operator requires [cert-manager](https://cert-manager.io/) for TLS certificate management.
If you already have cert-manager running in your cluster, skip this step.
Install cert-manager:
```console
kubectl apply --server-side -f=https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/examples/third-party/cert-manager.yaml
```
Wait for cert-manager to become ready:
```console
kubectl wait --for='condition=established' --timeout=60s crd/certificates.cert-manager.io crd/issuers.cert-manager.io
for deploy in cert-manager{,-cainjector,-webhook}; do
kubectl -n=cert-manager rollout status --timeout=10m deployment.apps/"${deploy}"
done
```
## Install ScyllaDB Operator
Install the ScyllaDB Operator:
```console
kubectl -n=scylla-operator apply --server-side -f=https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/deploy/operator.yaml
```
Wait for the operator to become ready:
```console
kubectl wait --for='condition=established' --timeout=60s crd/scyllaclusters.scylla.scylladb.com crd/nodeconfigs.scylla.scylladb.com crd/scyllaoperatorconfigs.scylla.scylladb.com crd/scylladbmonitorings.scylla.scylladb.com
kubectl -n=scylla-operator rollout status --timeout=10m deployment.apps/{scylla-operator,webhook-server}
```
## Install Prometheus Operator (optional)
Prometheus Operator is required only if you plan to use ScyllaDB monitoring (`ScyllaDBMonitoring` CRD).
If you do not need monitoring, skip this step.
```console
kubectl apply --server-side -f=https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/examples/third-party/prometheus-operator.yaml
```
```console
kubectl wait --for='condition=established' --timeout=60s crd/prometheuses.monitoring.coreos.com crd/servicemonitors.monitoring.coreos.com
```
## Next steps
- [Deploy ScyllaDB](https://operator.docs.scylladb.com/stable/deploy-scylladb/index.md) — choose a platform-specific reference deployment or deploy your first cluster.
# install-with-helm.md
# Install with Helm
This page walks you through installing ScyllaDB Operator and its dependencies using Helm charts. If you prefer applying raw manifests, see [Install with GitOps](https://operator.docs.scylladb.com/stable/install-operator/install-with-gitops.md). For Red Hat OpenShift, see [Install on OpenShift](https://operator.docs.scylladb.com/stable/install-operator/install-on-openshift.md).
#### NOTE
The Helm installation path supports single-datacenter deployments only.
For multi-datacenter ScyllaDB clusters, use the [GitOps installation path](https://operator.docs.scylladb.com/stable/install-operator/install-with-gitops.md).
#### WARNING
Helm does not support managing CustomResourceDefinition resources ([helm#5871](https://github.com/helm/helm/issues/5871), [helm#7735](https://github.com/helm/helm/issues/7735)). Helm only creates CRDs on the first install and **never updates them**. You must update CRDs manually with every Operator upgrade. For this reason, the [Install with GitOps](https://operator.docs.scylladb.com/stable/install-operator/install-with-gitops.md) path provides a more consistent experience.
#### NOTE
ScyllaDB Operator must run in the `scylla-operator` namespace.
## Prerequisites
- A Kubernetes cluster meeting the [infrastructure requirements](https://operator.docs.scylladb.com/stable/install-operator/provision-infrastructure/index.md).
- [`kubectl`](https://kubernetes.io/docs/tasks/tools/#kubectl) configured to communicate with the cluster.
- [Helm 3+](https://helm.sh/docs/intro/install/) installed.
## Add the Helm chart repository
```shell
helm repo add scylla https://scylla-operator-charts.storage.googleapis.com/stable
helm repo update
```
Verify the charts are available:
```shell
helm search repo scylla
```
**Expected output:** At least three charts: `scylla/scylla-operator`, `scylla/scylla-manager`, `scylla/scylla`.
## Install cert-manager
cert-manager provisions the TLS certificate for ScyllaDB Operator’s webhook server. If you already have cert-manager installed in your cluster, skip this step. If you want to provide your own webhook certificate, set `webhook.createSelfSignedCertificate: false` and provide `webhook.certificateSecretName` when installing the Operator chart.
You can install cert-manager using the bundled manifest:
```shell
kubectl apply --server-side -f=https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/examples/third-party/cert-manager.yaml
```
Or follow the [upstream cert-manager installation instructions](https://cert-manager.io/docs/installation/).
Wait for cert-manager to become available:
```shell
kubectl wait -n=cert-manager --for='condition=ready' pod -l app=cert-manager --timeout=60s
kubectl wait -n=cert-manager --for='condition=ready' pod -l app=cainjector --timeout=60s
kubectl wait -n=cert-manager --for='condition=ready' pod -l app=webhook --timeout=60s
```
## Install ScyllaDB Operator
```shell
helm install scylla-operator scylla/scylla-operator \
--create-namespace \
--namespace scylla-operator
```
To customize the deployment (image, resources, replicas, log level), create a values file and pass it with `--values`:
```shell
helm install scylla-operator scylla/scylla-operator \
--create-namespace \
--namespace scylla-operator \
--values my-operator-values.yaml
```
See the chart’s [values.yaml](https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/helm/scylla-operator/values.yaml) for all available options.
Wait for ScyllaDB Operator to become available:
```shell
kubectl -n=scylla-operator rollout status --timeout=10m deployment.apps/scylla-operator
kubectl -n=scylla-operator rollout status --timeout=10m deployment.apps/webhook-server
```
**Expected output:** Both Deployments report `successfully rolled out`.
## Install Prometheus Operator (optional)
Prometheus Operator is required only if you plan to use ScyllaDB monitoring (`ScyllaDBMonitoring` CRD).
If you do not need monitoring, skip this step.
```shell
kubectl apply -n=prometheus-operator --server-side -f=https://raw.githubusercontent.com/scylladb/scylla-operator/v1.22/examples/third-party/prometheus-operator.yaml
```
```shell
kubectl -n=prometheus-operator rollout status --timeout=10m deployment.apps/prometheus-operator
```
## Next steps
- [Deploy ScyllaDB](https://operator.docs.scylladb.com/stable/deploy-scylladb/index.md) — choose a platform-specific reference deployment or deploy your first cluster.
## Clean up
To remove the Helm releases:
```shell
helm uninstall scylla -n scylla
helm uninstall scylla-manager -n scylla-manager
helm uninstall scylla-operator -n scylla-operator
```
#### NOTE
Helm uninstall does not remove CRDs. To fully clean up, delete the CRDs manually after uninstalling:
```shell
kubectl delete crd scyllaclusters.scylla.scylladb.com nodeconfigs.scylla.scylladb.com scyllaoperatorconfigs.scylla.scylladb.com scylladbmonitorings.scylla.scylladb.com
```
## Related pages
- [Prerequisites](https://operator.docs.scylladb.com/stable/install-operator/index.md) — Kubernetes version requirements and platform-specific setup.
- [Install with GitOps](https://operator.docs.scylladb.com/stable/install-operator/install-with-gitops.md) — alternative installation path using manifests.
- [Install on OpenShift](https://operator.docs.scylladb.com/stable/install-operator/install-on-openshift.md) — installation path for Red Hat OpenShift via OLM.
# investigate-restarts.md
# Investigate pod restarts
Determine why a ScyllaDB pod or container restarted and collect the evidence needed for diagnosis or a support ticket.
## Identify that a restart occurred
Check the restart count:
```bash
kubectl -n scylla get pods -l scylla-operator.scylladb.com/pod-type=scylladb-node
```
A non-zero `RESTARTS` column indicates that one or more containers in the pod have restarted.
You can also compare the container start time against the pod creation time.
If the container started significantly later than the pod was created, the container has restarted:
```bash
kubectl -n scylla get pod -o jsonpath='Pod created: {.metadata.creationTimestamp}{"\n"}Container started: {.status.containerStatuses[?(@.name=="scylla")].state.running.startedAt}{"\n"}'
```
## Determine the restart reason
### Container status
```bash
kubectl -n scylla get pod -o jsonpath='{.status.containerStatuses}' | jq .
```
Key fields:
| Field | Description |
|-----------------------------------|---------------------------------------------------------------|
| `restartCount` | Total number of restarts for this container |
| `lastState.terminated.reason` | Why the container stopped (`OOMKilled`, `Error`, `Completed`) |
| `lastState.terminated.exitCode` | Process exit code (`137` = SIGKILL / OOMKilled, `1` = error) |
| `lastState.terminated.finishedAt` | Timestamp of the last termination |
### Pod events
```bash
kubectl -n scylla describe pod
```
Look for these events in the `Events` section:
| Event | Meaning |
|--------------------|------------------------------------------------------------|
| `Killing` | Container was killed (by kubelet or OOM killer) |
| `BackOff` | Container is in `CrashLoopBackOff` — restarting repeatedly |
| `OOMKilling` | Container exceeded its memory limit |
| `Unhealthy` | Liveness probe failed — kubelet killed the container |
| `FailedScheduling` | Pod cannot be placed on any node |
## Distinguish restart causes
### OOMKilled
**Indicators:**
- `lastState.terminated.reason: OOMKilled`
- `lastState.terminated.exitCode: 137`
**Common causes:**
- Memory limit too low for the workload.
- ScyllaDB memory allocation exceeds the container limit.
**Resolution:**
- Increase the memory limit in the ScyllaCluster spec.
- Review ScyllaDB memory usage via monitoring dashboards.
### Liveness probe failure
**Indicators:**
- Event: `Unhealthy` with `Liveness probe failed`
- Container restarted without `OOMKilled` reason.
**Common causes:**
- ScyllaDB unresponsive due to long GC pauses or compaction stalls.
- Node overloaded — too many concurrent operations.
**Resolution:**
- Check ScyllaDB logs for compaction or GC warnings.
- Review resource allocation (CPU, memory).
- Check for large partition warnings in logs.
### CrashLoopBackOff
**Indicators:**
- Pod status: `CrashLoopBackOff`
- Event: `BackOff`
**Common causes:**
- ScyllaDB fails to start — corrupt SSTables, invalid configuration, wrong seeds.
- Disk permission issues.
- Missing or invalid `io_properties.yaml`.
**Resolution:**
- Check previous container logs: `kubectl -n scylla logs -c scylla --previous`
- Verify configuration with `kubectl -n scylla describe scyllacluster `
### Node eviction
**Indicators:**
- Pod event: `Evicted`
- Node conditions show `MemoryPressure` or `DiskPressure`.
**Cause:** The Kubernetes node is under resource pressure and the kubelet evicted the pod.
**Resolution:**
- Check node conditions: `kubectl describe node `
- Ensure dedicated node pools with appropriate taints prevent co-scheduling with other workloads.
- See [Set up dedicated node pools](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/set-up-dedicated-node-pools.md).
## Collect evidence
When filing a support ticket or investigating further, collect a must-gather archive.
It includes previous container logs, full pod status, and events needed to diagnose restarts.
See [Collect debugging information](https://operator.docs.scylladb.com/stable/troubleshoot/collect-debugging-information/index.md) for instructions.
## Related pages
- [Collecting debugging information](https://operator.docs.scylladb.com/stable/troubleshoot/collect-debugging-information/index.md)
# ipv6-concepts.md
# IPv6 networking concepts
This document explains how IPv6 networking works in ScyllaDB clusters, including the design decisions and behaviors.
## Overview
IPv6 networking support in ScyllaDB Operator enables you to run ScyllaDB clusters on modern IPv6 networks. Understanding how IPv6 works in ScyllaDB helps you make informed decisions about network configuration.
## How IPv6 support works
### Operator orchestration
When you configure IPv6 networking via the `network.ipFamilies` field in the ScyllaCluster CRD, ScyllaDB Operator automatically orchestrates several components:
1. **ScyllaDB configuration**: Enables IPv6 DNS lookup, sets listen and broadcast addresses
2. **Service configuration**: Creates Kubernetes services with appropriate IP families
3. **Manager Agent**: Configures scylla-manager-agent for IPv6 connectivity
4. **Health probes**: Sets up readiness and liveness probes on IPv6 addresses
5. **Network policies**: Ensures proper IPv6 traffic flow
This automated configuration ensures all components work together correctly without manual intervention.
### Automatic vs manual configuration
The operator handles all IPv6 configuration automatically. You don’t need to:
- Set ScyllaDB command-line arguments directly
- Configure listen or broadcast addresses manually
- Modify manager agent configuration
- Adjust health probe settings
**You only configure**:
- `network.ipFamilies` - Which IP protocol(s) to use
- `network.ipFamilyPolicy` - How to handle dual-stack
- `network.dnsPolicy` - DNS resolution strategy
The operator translates these high-level settings into appropriate low-level configurations.
## IP family selection behavior
### Primary IP family determines ScyllaDB protocol
The **first** IP family in `network.ipFamilies` is critical - it determines which protocol ScyllaDB uses for **all** internal operations:
```yaml
# Example 1: ScyllaDB uses IPv6
network:
ipFamilies:
- IPv6 # ← ScyllaDB uses this
- IPv4 # Services also support this
```
```yaml
# Example 2: ScyllaDB uses IPv4
network:
ipFamilies:
- IPv4 # ← ScyllaDB uses this
- IPv6 # Services also support this
```
### Why first IP family matters
ScyllaDB requires consistent addressing for:
**Gossip protocol**: Nodes exchange cluster membership information using a single protocol. Mixed protocols would break gossip.
**Data replication**: When nodes replicate data, they must use the same IP protocol to establish connections.
**Broadcast addresses**: All nodes must be able to reach each other’s broadcast addresses using the same protocol.
**Token ring**: The consistent hash ring requires uniform addressing across all nodes.
### Service IP families
While ScyllaDB uses a single IP family, Kubernetes services can support multiple:
```yaml
network:
ipFamilies:
- IPv4 # ScyllaDB protocol
- IPv6 # Additional service accessibility
```
**Result**:
- Services get both IPv4 and IPv6 addresses
- Clients can discover services via either protocol
- ScyllaDB nodes communicate using IPv4 (the first family)
- Actual database connections still use IPv4
This provides client flexibility while maintaining internal consistency.
## Dual-stack behavior explained
Understanding dual-stack is key to successful IPv6 adoption.
### What dual-stack means
“Dual-stack” refers to **Kubernetes services** having both IPv4 and IPv6 addresses, not ScyllaDB itself.
**Dual-stack components**:
- Kubernetes Services: Have both IPv4 and IPv6 ClusterIPs
- DNS records: Have both A (IPv4) and AAAA (IPv6) records
- Client access: Clients can connect via either protocol
**Single-stack components**:
- ScyllaDB nodes: Use one IP protocol (the first in `ipFamilies`)
- Inter-node communication: Uses one protocol
- Data replication: Uses one protocol
### How dual-stack works

**Key insight**: Services provide protocol translation, allowing diverse clients to reach a cluster running on a single protocol.
## Client connectivity patterns
### Single-stack IPv4
```yaml
network:
ipFamilies:
- IPv4
```
**Behavior**:
- Services: IPv4 only
- ScyllaDB: IPv4 protocol
- Clients: Must support IPv4
**Use when**: Standard deployments, maximum compatibility
### Single-stack IPv6
```yaml
network:
ipFamilies:
- IPv6
```
**Behavior**:
- Services: IPv6 only
- ScyllaDB: IPv6 protocol
- Clients: Must support IPv6
**Use when**: IPv6-only networks (experimental)
### Dual-stack IPv4-primary
```yaml
network:
ipFamilies:
- IPv4
- IPv6
```
**Behavior**:
- Services: Both IPv4 and IPv6
- ScyllaDB: IPv4 protocol
- Clients: Can use either IPv4 or IPv6
**Use when**: Supporting diverse clients while keeping ScyllaDB on IPv4
### Dual-stack IPv6-primary
```yaml
network:
ipFamilies:
- IPv6
- IPv4
```
**Behavior**:
- Services: Both IPv6 and IPv4
- ScyllaDB: IPv6 protocol
- Clients: Can use either IPv6 or IPv4
**Use when**: Migrating to IPv6 while supporting legacy IPv4 clients
## DNS configuration and IPv6
DNS configuration is critical for IPv6 networking.
### Why ClusterFirst matters
```yaml
network:
dnsPolicy: ClusterFirst # Essential for IPv6
```
**ClusterFirst ensures**:
- Kubernetes DNS (CoreDNS) handles name resolution
- AAAA records (IPv6) are correctly resolved
- Service discovery works for IPv6 addresses
- Pod-to-pod DNS works across IP families
### Without ClusterFirst
If `dnsPolicy` is not `ClusterFirst`:
- DNS may use node’s resolver instead of cluster DNS
- AAAA records might not be resolved correctly
- ScyllaDB nodes may fail to discover each other
- Service names may resolve to wrong IP family
## Default behavior and fallbacks
Understanding defaults helps when troubleshooting.
### When network configuration is omitted
```yaml
# No network configuration
spec:
datacenter:
# ...
```
**Defaults**:
- `ipFamilies`: `[IPv4]`
- `ipFamilyPolicy`: Cluster default (usually `SingleStack`)
- `dnsPolicy`: `ClusterFirst`
**Result**: IPv4-only cluster (backward compatible)
### When ipFamilyPolicy is PreferDualStack
```yaml
network:
ipFamilyPolicy: PreferDualStack
ipFamilies:
- IPv4
- IPv6
```
**If cluster supports dual-stack**: Services get both IP families
**If cluster doesn’t support dual-stack**: Services get first IP family only (IPv4)
**Advantage**: Graceful degradation without configuration changes
## Multi-datacenter considerations
Multi-datacenter deployments have additional requirements.
### IP family consistency requirement
All datacenters **must** use the same IP family:
```yaml
# Datacenter 1
network:
ipFamilies:
- IPv6
# Datacenter 2 (must match)
network:
ipFamilies:
- IPv6 # ✓ Same as DC1
```
**Why this is required**:
**Cross-datacenter replication**: Nodes in different datacenters must replicate data. They need compatible addressing to establish connections.
**Gossip synchronization**: Gossip information must propagate across datacenters. Mixed protocols break gossip.
**Broadcast address reachability**: Each node’s broadcast address must be reachable from all datacenters.
**Token ring consistency**: The global token ring spans all datacenters and requires uniform addressing.
### Multi-datacenter services
Each datacenter’s services can be dual-stack even if ScyllaDB uses single-stack:
```yaml
# Datacenter 1
network:
ipFamilies:
- IPv6 # ScyllaDB protocol
- IPv4 # Service accessibility
# Datacenter 2
network:
ipFamilies:
- IPv6 # Same ScyllaDB protocol
- IPv4 # Service accessibility
```
This provides local client flexibility while maintaining cluster consistency.
## Production readiness
For authoritative information about production readiness and experimental status, see [Production readiness](https://operator.docs.scylladb.com/stable/reference/ipv6-configuration.md#production-readiness) in the configuration reference.
### Recommendation
Use **dual-stack** for production:
- Well-tested in CI/CD
- Provides fallback options
- Supports diverse clients
- Easier troubleshooting
For production IPv6-only support progress, see [#3211](https://github.com/scylladb/scylla-operator/issues/3211).
## Common misconceptions
### Misconception: Dual-stack means ScyllaDB uses both protocols
**Reality**: ScyllaDB uses the first IP family only. Services support both protocols.
### Misconception: Can mix IP families across datacenters
**Reality**: All datacenters must use the same IP family for ScyllaDB.
### Misconception: Can’t use IPv6 without IPv6-only networking
**Reality**: Dual-stack (IPv4 + IPv6) is recommended and well-supported.
## Related documentation
- [IPv6 configuration reference](https://operator.docs.scylladb.com/stable/reference/ipv6-configuration.md)
- [How to configure IPv6](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/configure-dual-stack.md)
- [Getting started with IPv6](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/get-started.md)
- [Troubleshoot IPv6 issues](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/troubleshooting.md)
# ipv6-configuration.md
# IPv6 configuration reference
This reference documents the IPv6-specific API fields, automatic ScyllaDB settings, validation rules, and version requirements for IPv6 networking.
For complete field definitions and schemas, see the ScyllaCluster API reference.
For setup instructions, see [IPv6 networking](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/index.md).
## Network configuration fields
IPv6 networking is configured through the `spec.network` section of a ScyllaCluster.
### `spec.network.ipFamilyPolicy`
Controls how Kubernetes assigns IP families to the Services created for ScyllaDB nodes. Defaults to `SingleStack`. Allowed values: `SingleStack` (single IP family only), `PreferDualStack` (both families if supported, falls back to single-stack), `RequireDualStack` (both families required, rejected if unsupported).
### `spec.network.ipFamilies`
A list of IP families (`IPv4`, `IPv6`) that the ScyllaDB cluster uses. Defaults to `[IPv4]` when omitted. The **first** entry determines which protocol ScyllaDB uses for all internal communication (`listen_address`, `rpc_address`, broadcast addresses, seed resolution).
The second entry (if present) is used only at the Kubernetes Service level for dual-stack accessibility.
### `spec.network.dnsPolicy`
Sets the DNS resolution policy for ScyllaDB pods. Defaults to `ClusterFirstWithHostNet`. Accepts any Kubernetes [DNSPolicy](https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/#pod-s-dns-policy). For IPv6 configurations, set this to `ClusterFirst` to ensure proper AAAA record resolution.
## Automatic ScyllaDB configuration
When `spec.network.ipFamilies` includes IPv6 as the first entry, the Operator automatically applies the following ScyllaDB arguments. You do not need to set these manually.
| ScyllaDB argument | IPv4 value | IPv6 value | Purpose |
|----------------------------|------------------------------------------|--------------|------------------------------------------------------------|
| `--listen-address` | `0.0.0.0` | `::` | Interface ScyllaDB listens on for inter-node communication |
| `--rpc-address` | not set (ScyllaDB defaults to `0.0.0.0`) | `::` | Interface ScyllaDB listens on for CQL client connections |
| `--enable-ipv6-dns-lookup` | not set | `1` | Enables AAAA DNS record resolution in ScyllaDB |
### Broadcast addresses
Broadcast addresses (`--broadcast-address` and `--broadcast-rpc-address`) are configured through `spec.exposeOptions.broadcastOptions`, not by setting ScyllaDB arguments directly. The Operator ensures broadcast addresses match the selected IP family.
## Validation rules
The Operator validates IPv6-related fields at admission time.
### Consistency requirements
- The first entry in `spec.network.ipFamilies` determines ScyllaDB’s protocol. All nodes in the cluster use the same protocol.
- If `--listen-address` or `--rpc-address` are set manually via `additionalScyllaDBArguments`, they must be compatible with the selected IP family. Values containing `:` are treated as IPv6; `0.0.0.0`, `::`, and empty strings are treated as wildcards and are valid for either family.
### Unsupported configurations
- Different IP families across datacenters in a multi-datacenter deployment.
- Changing the IP family of an existing cluster (requires cluster recreation).
## Example configurations
### IPv4 single-stack (default)
No `network` section is needed. IPv4 single-stack is the default behavior.
### IPv4-first dual-stack
```yaml
spec:
network:
ipFamilyPolicy: PreferDualStack
ipFamilies:
- IPv4
- IPv6
dnsPolicy: ClusterFirst
```
ScyllaDB uses IPv4 for internal communication. Services are accessible over both IPv4 and IPv6.
### IPv6-first dual-stack
```yaml
spec:
network:
ipFamilyPolicy: PreferDualStack
ipFamilies:
- IPv6
- IPv4
dnsPolicy: ClusterFirst
```
ScyllaDB uses IPv6 for internal communication. Services are accessible over both IPv6 and IPv4.
### IPv6-only single-stack
```yaml
spec:
network:
ipFamilyPolicy: SingleStack
ipFamilies:
- IPv6
dnsPolicy: ClusterFirst
```
Complete example manifests are available in the repository:
- [`examples/ipv6/scylla-cluster-dual-stack.yaml`](https://github.com/scylladb/scylla-operator/blob/master/examples/ipv6/scylla-cluster-dual-stack.yaml) — production-ready dual-stack setup
- [`examples/ipv6/scylla-cluster-minimal-dual-stack.yaml`](https://github.com/scylladb/scylla-operator/blob/master/examples/ipv6/scylla-cluster-minimal-dual-stack.yaml) — minimal dual-stack example
- [`examples/ipv6/scylla-cluster-ipv6.yaml`](https://github.com/scylladb/scylla-operator/blob/master/examples/ipv6/scylla-cluster-ipv6.yaml) — IPv6 single-stack setup
## Version requirements
### Minimum versions
- **ScyllaDB**: 2024.1 or newer
- **ScyllaDB Operator**: 1.20 or newer
## Production readiness
### Production-ready configurations
The following configurations are **production-ready**:
- **IPv4-only single-stack**: Fully supported (default Kubernetes behavior)
- **IPv4-first dual-stack**: Fully supported and recommended for IPv6 adoption
- **IPv6-first dual-stack**: Fully supported
### Experimental configurations
The following configurations are **experimental** and not recommended for production use:
- **IPv6-only single-stack**: Currently under development
#### NOTE
**Experimental status**: IPv6-only configurations work but have not undergone the same level of testing and validation as dual-stack configurations. For production IPv6 deployments, use dual-stack configurations instead.
Track progress on productionizing IPv6-only: [#3211](https://github.com/scylladb/scylla-operator/issues/3211)
## Related documentation
- [IPv6 networking concepts](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/ipv6-concepts.md)
- [Configure dual-stack networking](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/configure-dual-stack.md)
- [Get started with IPv6](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/get-started.md)
# known-issues.md
# Known issues
This page lists known issues, platform-specific caveats, and feature limitations in ScyllaDB Operator. For issues specific to Kubernetes environments, see [Supported Kubernetes environments](https://operator.docs.scylladb.com/stable/reference/releases.md).
## Platform-specific issues
### TRUNCATE queries fail when hairpinning is disabled
`TRUNCATE` queries require [hairpinning](https://en.wikipedia.org/wiki/Hairpinning) to be enabled on the container network bridge. On some environments this is disabled by default.
**Learn more**: [#163](https://github.com/scylladb/scylla-operator/issues/163)
**Workaround**:
```shell
ip link set promisc on
```
### ScyllaDB Manager fails to boot when hairpinning is disabled
If ScyllaDB Manager fails to apply the 8th migration (`008_*`), the cause is the same hairpinning issue. Apply the workaround above.
### EKS: webhook connectivity with custom CNI
On EKS clusters using a custom CNI plugin, webhook connectivity can break because the API server may be unable to reach webhook pods. This is an upstream issue.
**Reference**: [aws/containers-roadmap#1215](https://github.com/aws/containers-roadmap/issues/1215)
### GKE: private clusters require a firewall rule
GKE private clusters restrict communication from the API server to node pods. A firewall rule must be added to allow the API server to reach the webhook pod on the serving port.
**Reference**: [GKE private clusters — add firewall rules](https://cloud.google.com/kubernetes-engine/docs/how-to/latest/network-isolation#add_firewall_rules)
# manager.md
# ScyllaDB Manager
[ScyllaDB Manager](https://manager.docs.scylladb.com/) is a companion service that provides scheduled repairs and backups for ScyllaDB clusters.
ScyllaDB Operator integrates with Manager so that you can define repair and backup tasks declaratively in your cluster spec, without interacting with Manager directly.
## Deployment model
ScyllaDB Manager runs as a **single, shared Deployment** in the `scylla-manager` namespace.
One Manager instance serves all ScyllaDB clusters in the Kubernetes cluster.
Manager requires a small ScyllaDB database to store its own state (task definitions, run history, cluster metadata).
This is provided by a dedicated `ScyllaCluster` resource named `scylla-manager-cluster` in the `scylla-manager` namespace, running in developer mode with minimal resources (1 node, 1 CPU, 200 MiB memory).
#### NOTE
The backing ScyllaCluster has the annotation `scylla-operator.scylladb.com/disable-global-scylladb-manager-integration: "true"` to prevent it from being registered with the very Manager instance it supports.
Manager depends on ScyllaDB Operator — the Operator must be installed first because the backing cluster uses the `ScyllaCluster` CRD. Additionally, a [NodeConfig](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/configure-nodes.md) must be applied and the [ScyllaDB Local CSI Driver](https://github.com/scylladb/local-csi-driver) must be installed to provide storage for the backing cluster.
## Manager Agent
Each ScyllaDB pod runs a **ScyllaDB Manager Agent** as a sidecar container.
The Agent communicates with Manager to execute operations on the local node (streaming repair data, uploading backup snapshots to object storage, etc.).
The Agent:
- Listens on port 10001.
- Waits for [ignition](https://operator.docs.scylladb.com/stable/understand/ignition.md) and for the ScyllaDB REST API (port 10000) to become available before starting — this covers the gap between ignition completing and ScyllaDB finishing IO tuning on first boot.
- Is configured through layered YAML config files and an auth token that the Operator manages automatically.
- Uses the image specified by the `agentVersion` and `agentRepository` fields on the `ScyllaCluster` spec.
## Task synchronisation
The Operator bridges your cluster spec to Manager tasks through a chain of internal resources.
`ScyllaCluster` defines backup and repair tasks inline:
```yaml
spec:
backups:
- name: daily-backup
location:
- s3:my-bucket
retention: 7
cron: "0 2 * * *"
repairs:
- name: weekly-repair
cron: "0 0 * * 0"
```
The ScyllaCluster controller translates each entry into a `ScyllaDBManagerTask` resource in the same namespace.
### Reconciliation flow
1. The Operator creates an internal **`ScyllaDBManagerClusterRegistration`** resource to register the cluster with Manager.
2. The **ScyllaDBManagerClusterRegistration controller** calls the Manager REST API to register the cluster and stores the resulting cluster ID in its status.
3. The **ScyllaDBManagerTask controller** reads the registration, then creates, updates, or deletes tasks in Manager via its REST API.
4. Task statuses (run history, next run time, errors) are propagated back to the `ScyllaDBManagerTask` status and to the `.status.backups` and `.status.repairs` fields on the `ScyllaCluster`.
## Disabling Manager integration
If you do not want a ScyllaCluster to be managed by the shared Manager instance, add the annotation:
```yaml
metadata:
annotations:
scylla-operator.scylladb.com/disable-global-scylladb-manager-integration: "true"
```
This prevents the Operator from creating registration and task resources for that cluster.
## Security
Because Manager is a shared instance, access to the `scylla-manager` namespace grants control over **all** registered clusters’ repair and backup tasks.
The Manager Agent authenticates with Manager using an auth token.
The Operator generates and distributes these tokens automatically — one per cluster — via Secrets in the cluster’s namespace.
A `NetworkPolicy` in the `scylla-manager` namespace allows Manager to reach the backing ScyllaDB cluster pods within that namespace.
## Multi-datacenter Manager integration
In a multi-datacenter cluster built from multiple `ScyllaCluster` resources (one per Kubernetes cluster), ScyllaDB Manager must be deployed in **only one** datacenter. Manager communicates with all nodes across datacenters through the Manager Agent running in each pod.
Every `ScyllaCluster` is provisioned with a unique, randomly generated auth token stored in a Secret named `-auth-token`. For Manager to manage nodes in all datacenters, every datacenter must use the **same** auth token. You must manually synchronize the token:
1. **Extract the token** from the datacenter where Manager is deployed:
```shell
kubectl --context="${CONTEXT_DC1}" -n= get secrets/-auth-token \
--template='{{ index .data "auth-token.yaml" }}' | base64 -d
```
2. **Patch the token** into each remote datacenter’s Secret:
```shell
kubectl --context="${CONTEXT_DC2}" -n= patch secret/-auth-token \
--type='json' \
-p='[{"op": "add", "path": "/stringData", "value": {"auth-token.yaml": ""}}]'
```
3. **Rolling restart** the remote datacenter so the Agents pick up the new token:
```shell
kubectl --context="${CONTEXT_DC2}" -n= patch scyllacluster/ \
--type='merge' \
-p='{"spec": {"forceRedeploymentReason": "sync manager-agent auth token"}}'
```
4. **Define Manager tasks** on the `ScyllaCluster` in the Kubernetes cluster where Manager is running.
## Limitations
- **Restore** is not yet available through the Operator’s declarative API. To restore from a Manager backup, you must exec into the Manager pod and use `sctool` directly. See [Back up and restore](https://operator.docs.scylladb.com/stable/operate/back-up-and-restore.md).
- There is one global Manager instance per Kubernetes cluster. Multi-tenancy isolation between clusters sharing the same Manager is limited to auth tokens.
- Manager functionality beyond backup and repair (e.g., healthcheck configuration) is not yet exposed through CRDs.
# migrate-rack-to-new-node-pool.md
# Migrate a rack to a new node pool
Move a ScyllaDB rack from one Kubernetes node pool to another without downtime, by adding a new rack on the target node pool and gradually migrating data away from the old rack.
## When to use this procedure
Common reasons to migrate a rack to a new node pool:
- Upgrading to a different instance type (e.g. larger machines, newer generation).
- Moving to nodes with different storage configuration.
- Replacing a node pool that uses a deprecated OS image.
- Switching from a shared node pool to a dedicated one.
## Prerequisites
- The new node pool must already exist with appropriate labels, taints, and instance types.
See [Set up dedicated node pools](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/set-up-dedicated-node-pools.md) for setup.
- A `NodeConfig` resource targeting the new node pool must be applied (if your cluster uses tuning, RAID, or filesystem configuration).
See [Configure nodes](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/configure-nodes.md) for details.
- The replication factor of your keyspaces must be large enough to tolerate the temporary imbalance during migration.
For example, with RF=3 you can safely have one rack temporarily empty.
- The new rack must be in the same datacenter as the old rack.
## Procedure
The migration follows a gradual scale-up / scale-down pattern:
add nodes to the new rack one at a time, then remove nodes from the old rack one at a time.
Suppose you have a ScyllaCluster with a rack `us-east-1a` on the old node pool and you want to migrate it to a new node pool labelled `pool: scylladb-new`.
### Step 1: Add the new rack with zero members
Add a new rack to the spec that targets the new node pool.
Set `members: 0` initially — no pods are created yet.
```yaml
apiVersion: scylla.scylladb.com/v1
kind: ScyllaCluster
metadata:
name: scylla
namespace: scylla
spec:
datacenter:
name: us-east-1
racks:
- name: us-east-1a # old rack
members: 3
storage:
capacity: 500Gi
resources:
limits:
cpu: 4
memory: 8Gi
placement:
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: pool
operator: In
values:
- scylladb-old
tolerations:
- key: role
operator: Equal
value: scylladb
effect: NoSchedule
- name: us-east-1b # new rack — starts at 0
members: 0
storage:
capacity: 500Gi
resources:
limits:
cpu: 4
memory: 8Gi
placement:
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: pool
operator: In
values:
- scylladb-new
tolerations:
- key: role
operator: Equal
value: scylladb
effect: NoSchedule
```
Apply the change:
```bash
kubectl -n scylla apply -f scyllacluster.yaml
```
### Step 2: Scale up the new rack one node at a time
Increase the new rack’s `members` by 1.
Each new node joins the cluster, takes ownership of a token range, and begins streaming data from existing nodes.
```bash
kubectl -n scylla patch scyllacluster/scylla --type=json \
-p='[{"op": "replace", "path": "/spec/datacenter/racks/1/members", "value": 1}]'
```
Wait for the new node to be ready:
```bash
kubectl -n scylla wait --timeout=15m --for='condition=Available' scyllaclusters.scylla.scylladb.com/scylla
```
Verify the cluster state:
```bash
kubectl -n scylla exec -it scylla-us-east-1-us-east-1a-0 -c scylla -- nodetool status
```
Repeat this step until the new rack has the same number of members as the old rack.
### Step 3: Scale down the old rack one node at a time
Decrease the old rack’s `members` by 1.
The Operator decommissions the highest-ordinal node, streaming its data to the remaining nodes before deleting the pod.
```bash
kubectl -n scylla patch scyllacluster/scylla --type=json \
-p='[{"op": "replace", "path": "/spec/datacenter/racks/0/members", "value": 2}]'
```
Wait for the decommission to finish:
```bash
kubectl -n scylla wait --timeout=30m --for='condition=Available' scyllaclusters.scylla.scylladb.com/scylla
```
Repeat until the old rack has 0 members.
### Step 4: Remove the old rack
Once the old rack has 0 members, remove its definition from the spec:
```yaml
apiVersion: scylla.scylladb.com/v1
kind: ScyllaCluster
metadata:
name: scylla
namespace: scylla
spec:
datacenter:
name: us-east-1
racks:
- name: us-east-1b # only the new rack remains
members: 3
storage:
capacity: 500Gi
resources:
limits:
cpu: 4
memory: 8Gi
placement:
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: pool
operator: In
values:
- scylladb-new
tolerations:
- key: role
operator: Equal
value: scylladb
effect: NoSchedule
```
#### WARNING
Do not remove a rack from the spec while it still has members.
The Operator rejects this change through validation.
### Step 5: Run a repair
After migration, run a repair to ensure data consistency across the new token ranges:
```bash
kubectl -n scylla exec -it scylla-us-east-1-us-east-1b-0 -c scylla -- nodetool repair -pr
```
Or use a ScyllaDB Manager repair task if Manager is configured.
## Related pages
- [Scale, add, remove racks](https://operator.docs.scylladb.com/stable/operate/scale-add-remove-racks.md) — adding and removing racks, scaling up and down
- [StatefulSets and racks](https://operator.docs.scylladb.com/stable/understand/statefulsets-and-racks.md) — how racks map to StatefulSets, scaling mechanics, and decommission workflow
- [Set up dedicated node pools](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/set-up-dedicated-node-pools.md) — setting up node pools with labels, taints, and NodeConfig
# migration.md
# Migrate clusters to IPv6
This guide shows you how to migrate existing ScyllaDB clusters to IPv6 networking.
## Before you begin
### Prerequisites
- Existing ScyllaDB cluster running on IPv4
- Kubernetes cluster with IPv6 support enabled
- Administrative access to the cluster
### Important considerations
- **Downtime**: Migration requires a rolling restart of all pods
- **Data safety**: Data is preserved during migration
- **Client updates**: Client applications need updated connection strings after migration
- **Testing**: Test the migration process in a non-production environment first
#### WARNING
Migration involves a rolling restart of your cluster. Plan the migration during a maintenance window.
## Choose your migration path
Select the migration approach that fits your needs:
1. [Migrate from IPv4 to dual-stack](): Add IPv6 support while keeping IPv4 (recommended)
2. [Migrate from IPv4 to IPv6-only](): Completely migrate to IPv6 (experimental)
## Migrate from IPv4 to dual-stack
This is the recommended migration path because:
- Minimizes disruption to existing clients
- Allows gradual client migration
- Provides fallback to IPv4 if issues arise
### Step 1: Backup your data
Before making any changes, ensure you have recent backups. See [Configuring backup tasks](https://operator.docs.scylladb.com/stable/understand/manager.md) for details on setting up backups for your ScyllaCluster.
### Step 2: Update cluster configuration
Edit your ScyllaCluster manifest to add dual-stack support:
```yaml
apiVersion: scylla.scylladb.com/v1
kind: ScyllaCluster
metadata:
name: your-cluster-name
namespace: scylla
spec:
# ... existing configuration ...
# Add network configuration
network:
ipFamilyPolicy: PreferDualStack
ipFamilies:
- IPv4 # Keep IPv4 as primary
- IPv6 # Add IPv6 support
dnsPolicy: ClusterFirst
```
### Step 3: Apply the configuration
Apply the updated configuration:
```bash
kubectl apply -f scylla-cluster.yaml
```
The operator will perform a rolling update of all pods.
### Step 4: Monitor the migration
Watch the rolling update progress:
```bash
# Check cluster status
kubectl exec -it -n scylla -c scylla -- nodetool status
```
**Expected output:**
```default
Datacenter: dc
===================
Status=Up/Down
|/ State=Normal/Leaving/Joining/Moving
-- Address Load Tokens Owns Host ID Rack
UN 10.244.2.7 501.79 KB 256 ? 4583fff5-2aa6-4041-9be8-c74bcabaff8c rack
UN 10.244.2.8 494.49 KB 256 ? b1f889b4-80e7-4685-a3c5-1b81797c2ce4 rack
UN 10.244.2.9 494.96 KB 256 ? 7a4bb6da-415e-4fc3-a6ca-0369c0e76bf0 rack
```
Wait for all nodes to show `UN` (Up/Normal) status.
### Step 5: Verify dual-stack configuration
Confirm services have both IP families:
```bash
kubectl get svc -n scylla -o custom-columns=NAME:.metadata.name,IP-FAMILIES:.spec.ipFamilies,POLICY:.spec.ipFamilyPolicy
```
**Expected output:**
```default
NAME IP-FAMILIES POLICY
scylla-dual-stack-client [IPv4 IPv6] PreferDualStack
scylla-dual-stack-us-east-1a-0 [IPv4 IPv6] PreferDualStack
```
### Step 6: Test connectivity
Test that clients can connect via both protocols:
```bash
# Get service IPs
kubectl get svc your-cluster-name-client -n scylla -o jsonpath='{.spec.clusterIPs}'
```
**Example output**
```default
[
"10.96.136.229",
"fd00:10:96::6277"
]
```
Test connection using service name:
```bash
kubectl run -it --rm cqlsh --image=scylladb/scylla-cqlsh:latest --restart=Never -n scylla-test -- \
your-cluster-name-client.scylla.svc.cluster.local 9042 \
-e "SELECT cluster_name,broadcast_address FROM system.local;"
```
**Example output**
```default
-------------------+---------------------
cluster_name | scylla-cluster
broadcast_address | 10.244.2.42
(1 rows)
pod "cqlsh" deleted
```
### Step 7: Update client applications
Update your client applications to use the dual-stack service. Most clients will automatically work with dual-stack services without changes.
### Step 8: Verify cluster health
After migration completes:
```bash
# Verify all nodes are up
kubectl exec -it -n scylla -c scylla -- nodetool status
```
## Migrate from IPv4 to IPv6-only
#### WARNING
**Experimental Feature**: IPv6-only configurations are experimental. See [Production readiness](https://operator.docs.scylladb.com/stable/reference/ipv6-configuration.md#production-readiness) for details. This migration path requires careful planning and testing.
### Step 1: Verify IPv6-only readiness
Ensure your environment supports IPv6-only:
```bash
# Check that all nodes have IPv6 addresses
kubectl get nodes -o jsonpath='{.items[*].status.addresses[?(@.type=="InternalIP")].address}' | tr ' ' '\n' | grep ':'
```
**Example output**
```default
fc00:f853:ccd:e793::2
fc00:f853:ccd:e793::4
fc00:f853:ccd:e793::3
fc00:f853:ccd:e793::5
```
### Step 2: Update client applications
Update all client applications to support IPv6 before migrating the cluster.
### Step 3: Backup your data
Create a backup before proceeding. See [Configuring backup tasks](https://operator.docs.scylladb.com/stable/understand/manager.md) for details on setting up backups for your ScyllaCluster.
### Step 4: Update cluster configuration
Edit your ScyllaCluster manifest for IPv6-only:
```yaml
apiVersion: scylla.scylladb.com/v1
kind: ScyllaCluster
metadata:
name: your-cluster-name
namespace: scylla
spec:
# ... existing configuration ...
# Update network configuration
network:
ipFamilyPolicy: SingleStack
ipFamilies:
- IPv6 # IPv6 only
dnsPolicy: ClusterFirst
```
### Step 5: Apply and monitor
Apply the configuration and monitor the migration:
```bash
kubectl apply -f scylla-cluster.yaml
# Monitor the rolling update
kubectl get pods -n scylla -w
```
### Step 6: Verify IPv6-only operation
Check that cluster is using IPv6:
```bash
# Verify pod IPv6 addresses
kubectl get pods -n scylla -o wide
# Check cluster status
kubectl exec -it -n scylla -c scylla -- nodetool status
```
**Expected output with IPv6 addresses:**
```default
Datacenter: datacenter
===================
Status=Up/Down
|/ State=Normal/Leaving/Joining/Moving
-- Address Load Tokens Owns Host ID Rack
UN fd00:10:244:1::7f 501.79 KB 256 ? 4583fff5-2aa6-4041-9be8-c74bcabaff8c rack
UN fd00:10:244:2::6d 494.49 KB 256 ? b1f889b4-80e7-4685-a3c5-1b81797c2ce4 rack
UN fd00:10:244:3::6c 494.96 KB 256 ? 7a4bb6da-415e-4fc3-a6ca-0369c0e76bf0 rack
```
### Step 7: Test client connectivity
Test that clients can connect:
```bash
kubectl run -it --rm cqlsh --image=scylladb/scylla-cqlsh:latest --restart=Never -n scylla-test -- \
your-cluster-name-client.scylla.svc.cluster.local 9042 \
-e "SELECT cluster_name,broadcast_address FROM system.local;"
```
**Expected output:**
```default
-------------------+---------------------
cluster_name | scylla-cluster
broadcast_address | fd00:10:244:2::25
(1 rows)
pod "cqlsh" deleted
```
### Step 8: Verify cluster health
Check cluster health:
```bash
# Verify all nodes are up
kubectl exec -it -n scylla -c scylla -- nodetool status
```
## Rollback to IPv4
If you encounter issues during migration, you can roll back to the previous IPv4-only configuration.
Update your ScyllaCluster manifest:
```yaml
network:
ipFamilyPolicy: SingleStack
ipFamilies:
- IPv4
```
Apply the rollback:
```bash
kubectl apply -f scylla-cluster.yaml
```
The operator will perform a rolling update back to IPv4.
## Troubleshooting
If you encounter problems during migration:
### Nodes not joining cluster
**Symptom**: Pods are running but nodes show as down
**Solution**:
1. Check DNS resolution:
```bash
kubectl exec -it -n scylla -- nslookup
```
2. Verify network configuration:
```bash
kubectl get svc -n scylla -o yaml | grep -A 5 -i family
```
3. Review pod logs:
```bash
kubectl logs -n scylla -c scylla
```
### Connection failures
**Symptom**: Clients cannot connect after migration
**Solution**:
1. Verify service IPs:
```bash
kubectl get svc -n scylla -o wide
```
2. Check client configuration for IPv6 support
For more troubleshooting steps, see [Troubleshoot IPv6 issues](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/troubleshooting.md).
## Migration best practices
1. **Test first**: Always test migration in a non-production environment
2. **Backup**: Create backups before starting migration
3. **Monitoring**: Set up alerts for cluster health during migration
4. **Gradual approach**: Use dual-stack first, then migrate to IPv6-only if needed
5. **Client coordination**: Coordinate with application teams before migration
6. **Documentation**: Document your specific migration steps and any customizations
## Next steps
- [Troubleshoot IPv6 issues](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/troubleshooting.md)
- [Configure IPv6 networking](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/configure-dual-stack.md)
- [Understand IPv6 networking concepts](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/ipv6-concepts.md)
## Related documentation
- [How to configure IPv6 networking](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/configure-dual-stack.md)
- [Troubleshoot IPv6 networking](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/troubleshooting.md)
- [IPv6 networking concepts](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/ipv6-concepts.md)
- [IPv6 configuration reference](https://operator.docs.scylladb.com/stable/reference/ipv6-configuration.md)
# monitoring.md
# ScyllaDB Monitoring overview
## Architecture
ScyllaDB [exposes](https://monitoring.docs.scylladb.com/stable/reference/monitoring-apis.html) its metrics in the Prometheus format.
ScyllaDB Operator provides the [`ScyllaDBMonitoring`](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/scylladbmonitorings.md) custom resource
that allows you to set up a complete monitoring stack for your ScyllaDB clusters based on the following components:
- [**Prometheus**](https://prometheus.io) for metrics collection and alerting (scraping ScyllaDB and host-level metrics, and alerting rules targeting ScyllaDB instances).
- [**Grafana**](https://grafana.com) for metrics visualization (with pre-configured dashboards for ScyllaDB).
#### NOTE
The `ScyllaDBMonitoring` CRD is still in its `v1alpha1` version, yet it is considered stable and ready for production use, with
the following caveats:
- `spec.components.grafana.exposeOptions` and `spec.components.prometheus.exposeOptions` are deprecated and will be removed in the next API version,
- the **Managed** mode is deprecated; the **External** mode for Prometheus is likely to be the only supported mode in the next API version.
## Prometheus
For deploying and/or configuring Prometheus, ScyllaDB Operator relies on [Prometheus Operator](https://github.com/prometheus-operator/prometheus-operator).
ScyllaDB Operator supports two modes of operation for `ScyllaDBMonitoring` regarding Prometheus deployment:
**Managed** and **External**. You can choose the mode that best fits your needs by setting the `spec.components.prometheus.mode` field in the `ScyllaDBMonitoring` resource.
Depending on the mode chosen, ScyllaDB Operator may deploy and manage a Prometheus instance for you, or it can be configured to use
an existing Prometheus instance (managed by the Prometheus Operator) in your cluster.
The following Prometheus Operator resources are created by ScyllaDB Operator when you deploy a `ScyllaDBMonitoring` resource:
- [`Prometheus`](https://github.com/prometheus-operator/prometheus-operator/blob/e4c727291acc543dab531bc4aaf16637067c1b86/pkg/apis/monitoring/v1/prometheus_types.go#L1085) - the Prometheus instance itself (it may be omitted in External mode).
- [`ServiceMonitor`](https://github.com/prometheus-operator/prometheus-operator/blob/e4c727291acc543dab531bc4aaf16637067c1b86/pkg/apis/monitoring/v1/servicemonitor_types.go#L41) - the resource that defines how to scrape metrics from ScyllaDB nodes.
- [`PrometheusRule`](https://github.com/prometheus-operator/prometheus-operator/blob/e4c727291acc543dab531bc4aaf16637067c1b86/pkg/apis/monitoring/v1/prometheusrule_types.go#L37) - the resource that defines alerting rules for Prometheus.
The Prometheus version used in the deployment is tied to the version of ScyllaDB Operator. You can find the exact version used in the
[`config.yaml`](https://github.com/scylladb/scylla-operator/blob/master/assets/config/config.yaml) file under `operator.prometheusVersion` key.
Alongside ScyllaDB’s own metrics, Prometheus also collects metrics from `scylladb-node-exporter`, ScyllaDB’s packaging of the [Prometheus node_exporter agent](https://github.com/prometheus/node_exporter),
exposing host/OS-level metrics (CPU, memory, disk I/O, network, filesystem) from every ScyllaDB Pod.
This is what feeds the OS-level dashboards in ScyllaDB Monitoring’s Grafana.
For ScyllaDB version 2026.3 or later, ScyllaDB Operator deploys a dedicated `scylladb-node-exporter` sidecar Container inside the Pod; for earlier versions, the
exporter runs as a process inside the main ScyllaDB Container.
### External
The **External** mode plugs into an existing Prometheus that is managed by Prometheus Operator (and therefore can be configured by `ServiceMonitor`).
In the **External** mode, ScyllaDB Operator will not deploy a `Prometheus` resource (will instead expect a running Prometheus in the cluster already), but it will still create the `ServiceMonitor` and `PrometheusRule` resources
that an existing Prometheus Operator in your cluster will use to configure your Prometheus instance. This mode is useful if you already have a Prometheus instance
deployed in your cluster, and you want to use it for monitoring your ScyllaDB clusters. If you don’t have Prometheus deployed in your cluster, you need to deploy one to proceed.
When using this mode, you need to ensure that the existing Prometheus instance is configured to discover and scrape the
`ServiceMonitor` and `PrometheusRule` resources created by ScyllaDB Operator. Please refer to the [Setting up ScyllaDB Monitoring](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-monitoring/setup.md#deploy-prometheus-instance) guide for more details.
Please note that in this mode, `ScyllaDBMonitoring` has to be configured so that Grafana can access the Prometheus instance.
You can configure Grafana datasources in the `spec.components.grafana.datasources` field of the `ScyllaDBMonitoring` resource.
Please refer to the [`ScyllaDBMonitoring` API reference](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/scylladbmonitorings.md) for details.
### Managed
#### NOTE
This mode is deprecated and will be removed in a future version. Instead, please deploy your own Prometheus and use **External**.
In the **Managed** mode, ScyllaDB Operator will deploy a Prometheus instance for you. This is the default mode.
What this means is that when you create a `ScyllaDBMonitoring` resource, ScyllaDB Operator will create a `Prometheus`
resource (from the [Prometheus Operator](https://github.com/prometheus-operator/prometheus-operator)) in the same namespace as the `ScyllaDBMonitoring` resource.
This Prometheus instance will be configured to scrape metrics from the ScyllaDB nodes in the cluster that `ScyllaDBMonitoring` is monitoring and
will also have alerting rules configured for ScyllaDB (using `ServiceMonitor` and `PrometheusRule` CRs).
### Node exporter resource boundaries and limitations
Because `scylladb-node-exporter` runs within the ScyllaDB Pod’s namespaces rather than directly on the host, the metrics it exposes reflect these isolation boundaries:
| Domain | Namespace isolation | Metric effect and limitations |
|-----------------------------------|------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| **CPU, memory, and system state** | Reads host-level `/proc` and `/sys` filesystems without cgroup-scoped constraints. | Metrics (like CPU, memory, disk I/O, and vmstat) report global Node-wide resource usage rather than Pod-level resource limits. When running multiple ScyllaDB Pods on the same Node, their exporters report identical and duplicated Node-level values. |
| **Network** | Restricted to the Pod’s network namespace. | Network and TCP metrics reflect the Pod’s virtual ethernet interface (`veth`) and namespace activity, not the physical host network interface cards (NICs). Host-level NIC ethtool allowance counters are unavailable and return zero. |
| **Storage and filesystem** | Restricted to the Container’s mount namespace. | Filesystem metrics report capacity and usage for paths mounted inside the Container (such as the `/var/lib/scylla` volume). They do not reflect the physical host’s mount namespace, meaning the host’s actual root partition and other host-level mounts are completely invisible. |
## Grafana
For deploying Grafana, ScyllaDB Operator doesn’t use any third-party operator. Instead, it manages the Grafana deployment
directly. It preconfigures Grafana with dashboards from [scylla-monitoring](https://github.com/scylladb/scylla-monitoring/).
The Grafana image used in the deployment is tied to the version of ScyllaDB Operator. You can find the exact image used in the
[config.yaml](https://github.com/scylladb/scylla-operator/blob/master/assets/config/config.yaml) file under `operator.grafanaImage` key.
### Expose Grafana
ScyllaDB Operator creates a `ClusterIP` Service named `-grafana` for each `ScyllaDBMonitoring`.
You can access it outside the cluster using your preferred method:
- Port forwarding using `kubectl port-forward` command for temporary access.
- Using [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/) or [Gateway API](https://gateway-api.sigs.k8s.io/)
resources (e.g., HTTPRoute) for production access.
You can learn more about exposing Grafana in the [Expose Grafana](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-monitoring/exposing-grafana.md) guide.
## Related pages
- [Set up ScyllaDB Monitoring](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-monitoring/setup.md) — deploy Prometheus and configure `ScyllaDBMonitoring` for your cluster.
- [Set up ScyllaDB Monitoring on OpenShift](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-monitoring/external-prometheus-on-openshift.md) — use OpenShift User Workload Monitoring as an external Prometheus source.
- [Expose Grafana](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-monitoring/exposing-grafana.md) — make the Grafana dashboard accessible outside the cluster.
# must-gather-contents.md
# must-gather contents
This page describes the structure of a must-gather archive and how to find specific information within it.
## Archive structure
### Collection log
`/scylla-operator-must-gather.log` describes collection success or failure on the resource level.
### ScyllaCluster objects
Find them with:
```bash
grep -rl "^kind: ScyllaCluster"
```
Each file contains:
- Status conditions (`Available` / `Progressing` / `Degraded`) and their details.
- ScyllaDB configuration.
- Rack configurations (number of nodes, resource requests).
### ScyllaDB racks
Racks are represented by StatefulSets in the same namespace as the ScyllaCluster object:
```default
/namespaces//statefulsets.apps/--
```
### ScyllaDB nodes
Each node is represented by several Kubernetes resources in the same namespace as the ScyllaCluster:
**Pod** — `/namespaces//pods/---.yaml`
The corresponding directory `/namespaces//pods/---/` includes items collected from the ScyllaDB node:
- `nodetool-status.log` — output of `nodetool status`
- `nodetool-gossipinfo.log` — output of `nodetool gossipinfo`
- `df.log` — disk usage
- `io_properties.yaml` — ScyllaDB IO properties configuration
- `scylla-rlimits.log` — resource limits of the ScyllaDB process
- `scylla.current` and `scylla.previous` — ScyllaDB logs
**Service** — `/namespaces//services/---.yaml`
Contains:
- The state of a node replace in progress.
- The HostID as seen by Operator.
- Network configuration, including IP addresses.
**PersistentVolumeClaim** — `/namespaces//persistentvolumeclaims/...`
Contains:
- The type of storage (StorageClass) in use.
- A reference to the PersistentVolume that maps to an actual directory on the disk.
**Jobs** — `/namespaces//jobs.batch/...`
Contains references to Pods (for example, cleanup Jobs).
## Structure of a Kubernetes object
A typical object is located at `/namespaces///.yaml`:
```yaml
apiVersion: /v1
kind:
metadata:
name:
namespace:
creationTimestamp: ...
# deletionTimestamp and finalizers are present when deletion is in progress
# (useful for investigating why `kubectl delete` is hanging)
spec:
# Declarative configuration
status:
# This is the interesting part most of the time
conditions:
# Contains Available/Progressing/Degraded details
```
## Find information in the archive
### Diagnose a stuck resource
Look at status conditions:
```bash
grep -rl '^kind: ScyllaCluster'
grep -rl '^kind: NodeConfig'
grep -rl '^kind: ScyllaDBManagerTask'
grep -rl '^kind: ScyllaOperatorConfig'
```
Open the files and look under `.status.conditions`. Each condition has a `type` (`Available`, `Progressing`, `Degraded`, or something more granular).
See [Conditions](https://operator.docs.scylladb.com/stable/reference/conditions.md) for a detailed reference.
- **Available**: Everything should be up and running. Check `Progressing` for any non-disruptive operations in progress.
- **Progressing**: Operator is trying to make a change. If stuck, look at the Operator logs.
- **Degraded**: Something failed. Look at the `reason` and the Operator logs.
Pay attention to conditions where `reason` is not `AsExpected`.
### Find Operator logs
```default
/namespaces/scylla-operator/pods/scylla-operator-/scylla-operator.current
```
#### NOTE
There will typically be more than one Operator Pod (in an active-standby configuration).
### Find ScyllaDB logs by rack name and node number
List all ScyllaDB logs:
```bash
find -type f -name scylla.current
```
To find logs for a specific node, first identify the ScyllaCluster:
```bash
grep -rl "^kind: ScyllaCluster"
# Example output: namespaces/scylla/scyllaclusters.scylla.scylladb.com/my-cluster.yaml
```
Then find the logs at:
```default
namespaces//pods/---/scylla.current
```
### Find ScyllaDB logs by HostID
Look at the HostIDs of node Services:
```bash
grep "internal.scylla-operator.scylladb.com/host-id" \
/namespaces//services/*.yaml
```
Example output:
```default
namespaces/scylla/services/my-cluster-dc-rack-0.yaml: internal.scylla-operator.scylladb.com/host-id: 1849fd66-13ef-490e-846d-fabe55e08000
namespaces/scylla/services/my-cluster-dc-rack-1.yaml: internal.scylla-operator.scylladb.com/host-id: d2241fb5-1cf0-4c2e-86fb-b21cfd936f91
```
Find the Service matching your HostID, then look at the corresponding Pod logs:
```default
namespaces//pods//scylla.current
```
### Find ScyllaDB configuration
- Look at `.spec` of the ScyllaCluster object, particularly the ConfigMap referenced by `.spec.datacenter.racks[].scyllaConfig`.
- Look at the ScyllaDB command line arguments in the ScyllaDB node logs.
#### NOTE
Operator generates `scylla.yaml` from settings in the ScyllaCluster spec.
must-gather does not currently collect the resulting effective `scylla.yaml`.
## Too much data collected?
- [Limit collection to a particular namespace](https://operator.docs.scylladb.com/stable/troubleshoot/collect-debugging-information/must-gather.md#limit-collection-to-a-particular-namespace) by passing the `--namespace` flag.
- [Exclude resources](https://operator.docs.scylladb.com/stable/troubleshoot/collect-debugging-information/must-gather.md#exclude-resources) by passing the `--exclude-resource` flag.
- Manually curate the archive to remove information you do not want to include.
## Missing information?
The information collected from ScyllaDB Pods is implemented in [podcollector.go](https://github.com/scylladb/scylla-operator/blob/master/pkg/gather/collect/podcollector.go).
If must-gather does not collect information you need, [file a feature request](https://github.com/scylladb/scylla-operator/issues/new) or submit a PR.
## Related pages
- [Collect data with must-gather](https://operator.docs.scylladb.com/stable/troubleshoot/collect-debugging-information/must-gather.md)
- [Query system tables](https://operator.docs.scylladb.com/stable/troubleshoot/collect-debugging-information/system-tables.md)
# must-gather.md
# Collect data with must-gather
`must-gather` is a tool embedded in ScyllaDB Operator that collects diagnostic information equivalent to a debugging session, including:
- A snapshot of ScyllaDB configuration.
- A snapshot of Operator runtime state (status conditions, node service labels).
- A snapshot of Operator and ScyllaDB logs.
- A snapshot of the sequence of events (Kubernetes Events, object creation/deletion information).
## Prerequisites
All examples assume you have exported the `KUBECONFIG` environment variable pointing to a kubeconfig file on your machine.
If not, export the common default location:
```bash
export KUBECONFIG=~/.kube/config
ls -l "${KUBECONFIG}"
```
#### NOTE
There can be slight deviations in the arguments for your container tool, depending on the container runtime, whether you use SELinux, or similar factors.
As an example, the need for the `Z` option on volume mounts depends on whether you use SELinux and what context is applied on your file or directory.
If you get an error mentioning `Error: lsetxattr : operation not supported`, try it without the `Z` option.
### Use an external authentication plugin
Check whether your kubeconfig uses an [external authentication plugin](https://kubernetes.io/docs/reference/access-authn-authz/authentication/#client-go-credential-plugins) by running:
```bash
kubectl config view --minify
```
Look for this pattern (containing the `exec` key):
```yaml
users:
- name:
user:
exec:
```
If your kubeconfig does not use an external exec plugin, skip the rest of this section.
If your kubeconfig depends on external binaries, the external binary will not be available within the container to authenticate requests.
Create a dedicated ServiceAccount for must-gather and use it to run the tool:
```bash
kubectl create namespace must-gather
kubectl -n must-gather create serviceaccount must-gather
kubectl create clusterrolebinding must-gather --clusterrole=cluster-admin --serviceaccount=must-gather:must-gather
export MUST_GATHER_TOKEN
MUST_GATHER_TOKEN=$( kubectl -n must-gather create token must-gather --duration=1h )
kubeconfig=$( mktemp )
# Create a copy of the existing kubeconfig and
# replace user authentication using yq, or by adjusting the fields manually.
kubectl config view --minify --raw -o yaml | yq -e '.users[0].user = {"token": env(MUST_GATHER_TOKEN)}' > "${kubeconfig}"
KUBECONFIG="${kubeconfig}"
```
#### NOTE
If you do not have `yq` installed, you can get it at https://github.com/mikefarah/yq/#install or replace the user authentication settings manually.
When you are done using must-gather, remove the Kubernetes resources created for that purpose.
## Run must-gather
Run the must-gather container image, mounting your kubeconfig and a local directory for the output:
Docker
```bash
docker run -it --pull=always --rm \
-v="${KUBECONFIG}:/kubeconfig:ro" \
-v="$( pwd ):/workspace" \
--workdir=/workspace \
docker.io/scylladb/scylla-operator:latest must-gather \
--kubeconfig=/kubeconfig
```
Podman
```bash
podman run -it --pull=always --rm \
-v="${KUBECONFIG}:/kubeconfig:ro,Z" \
-v="$( pwd ):/workspace:Z" \
--workdir=/workspace \
docker.io/scylladb/scylla-operator:latest must-gather \
--kubeconfig=/kubeconfig
```
Expected output (similar to):
```default
I1029 11:40:59.708164 1 operator/gatherbase.go:119] "Created destination directory" Path="scylla-operator-must-gather-kns4cpxtnwmg"
I1029 11:40:59.708640 1 cmdutil/helpers.go:106] "Starting must-gather" GitCommit="\"2621bad4d\""
I1029 11:40:59.709003 1 operator/mustgather.go:253] "Gathering artifacts" DestDir="scylla-operator-must-gather-kns4cpxtnwmg"
I1029 11:41:06.549330 1 operator/mustgather.go:255] "Finished gathering artifacts" Duration="6.840317591s"
```
The output directory (here `scylla-operator-must-gather-kns4cpxtnwmg`) contains the collected archive.
See [must-gather contents](https://operator.docs.scylladb.com/stable/troubleshoot/collect-debugging-information/must-gather-contents.md) for details on navigating the archive.
## Inspect the archive for sensitive information
By default, sensitive resources (`Secrets` and `bitnami.com.SealedSecrets`) are omitted from the collection.
However, before sharing the archive, inspect it on your own to ensure nothing unexpected is included:
```bash
grep -r -l '^kind: Secret'
```
Redact or delete sensitive information if necessary.
## Limit collection to a particular namespace
If you are running a large Kubernetes cluster with many ScyllaClusters, limit the collection to a particular namespace:
```bash
scylla-operator must-gather --namespace=""
```
#### NOTE
The `--namespace` flag affects only ScyllaClusters.
Other resources related to the Operator installation or cluster state are still collected from other namespaces.
## Collect every resource in the cluster
By default, must-gather collects only a predefined subset of resources.
Request collecting every resource in the Kubernetes API if the default set is not sufficient:
```bash
scylla-operator must-gather --all-resources
```
## Include sensitive resources
Override the default behavior of omitting sensitive resources by passing the `--include-sensitive-resources` flag:
```bash
scylla-operator must-gather --all-resources --include-sensitive-resources
```
## Exclude resources
Exclude specific resources from the collection by passing the `--exclude-resource` flag:
```bash
scylla-operator must-gather --all-resources \
--exclude-resource="LimitRange" \
--exclude-resource="DeviceClass.resource.k8s.io"
```
#### NOTE
The format for the resource is `kind` (for core resources) or `kind.group`. Examples: `LimitRange` or `DeviceClass.resource.k8s.io`.
## Related pages
- [must-gather contents](https://operator.docs.scylladb.com/stable/troubleshoot/collect-debugging-information/must-gather-contents.md)
- [Query system tables](https://operator.docs.scylladb.com/stable/troubleshoot/collect-debugging-information/system-tables.md)
# networking.md
# Networking
This page explains how ScyllaDB Operator exposes ScyllaDB nodes on the network, how broadcast addresses work, and how IP family selection affects the cluster.
## Services created by the Operator
For every ScyllaDB cluster the Operator manages two kinds of Kubernetes Service:
| Service | Count | Purpose |
|-----------------------------------------|--------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| **Identity** (named `-client`) | One per datacenter | Stable DNS names for the StatefulSet. A regular `ClusterIP` Service shared by all racks’ StatefulSets as their `serviceName`, so that each pod gets a predictable DNS record (`.-client..svc.cluster.local`). Also serves as a client entry point that load-balances across all ScyllaDB pods. |
| **Member** | One per pod | A dedicated Service whose type is controlled by `exposeOptions.nodeService.type`. Carries the address that is broadcast to clients or other nodes. |
The member Service uses a selector that matches exactly one pod, giving every ScyllaDB node its own stable network identity independent of the pod IP lifecycle.
## Node Service types
The `exposeOptions.nodeService.type` field controls what kind of member Service the Operator creates for each ScyllaDB node.
### Headless
Creates a [headless Service](https://kubernetes.io/docs/concepts/services-networking/service/#headless-services) (`clusterIP: None`). The DNS record for the Service resolves directly to the pod IP. No additional IP address is allocated.
Use Headless when pods broadcast their own IP and no cluster-internal virtual IP is needed — for example, in multi-VPC deployments where pod IPs are routable across VPCs.
### ClusterIP
Creates a standard [ClusterIP Service](https://kubernetes.io/docs/concepts/services-networking/service/#type-clusterip) backed by a single pod. The Service receives a virtual IP that is routable only inside the Kubernetes cluster.
This is the **default** for `ScyllaCluster`.
### LoadBalancer
Creates a [LoadBalancer Service](https://kubernetes.io/docs/concepts/services-networking/service/#loadbalancer). On cloud platforms that support external load balancers the Service provisions one, giving each ScyllaDB node an externally reachable address.
Customisations such as restricting a load balancer to the internal network are managed through annotations on the Service. The `annotations` field in `nodeService` is merged into every member Service.
LoadBalancer Services are a superset of ClusterIP Services — every LoadBalancer Service also has a ClusterIP. Additional fields that propagate to member Services:
- `externalTrafficPolicy`
- `internalTrafficPolicy`
- `loadBalancerClass`
- `allocateLoadBalancerNodePorts`
#### Platform-specific annotations
EKS
```yaml
exposeOptions:
nodeService:
type: LoadBalancer
annotations:
service.beta.kubernetes.io/aws-load-balancer-scheme: internal
service.beta.kubernetes.io/aws-load-balancer-backend-protocol: tcp
```
GKE
```yaml
exposeOptions:
nodeService:
type: LoadBalancer
annotations:
networking.gke.io/load-balancer-type: Internal
```
## Broadcast options
ScyllaDB uses two broadcast addresses:
- **`broadcast_address`** — the address other ScyllaDB nodes use to reach this node (gossip, streaming, repair).
- **`broadcast_rpc_address`** — the address CQL clients use to connect to this node (returned during driver discovery).
The Operator lets you configure these independently via `exposeOptions.broadcastOptions.nodes` and `exposeOptions.broadcastOptions.clients`. Separating the two is useful when node-to-node traffic and client traffic travel over different networks for cost, latency, or security reasons.
### Broadcast address types
| Type | Address source | When to use |
|----------------------------------|---------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------|
| **`PodIP`** | Pod’s IP from `status.podIP` (or a specific entry in `status.podIPs` selected by IP family) | Pod IPs are routable from wherever the consumer lives — for example, within a VPC or across peered VPCs. |
| **`ServiceClusterIP`** | `spec.clusterIP` of the member Service | Consumers are inside the same Kubernetes cluster. Requires `nodeService.type` to be `ClusterIP` or `LoadBalancer`. |
| **`ServiceLoadBalancerIngress`** | First entry in `status.loadBalancer.ingress` (IP or hostname) of the member Service | Consumers are outside the Kubernetes cluster and reach nodes through a load balancer. Requires `nodeService.type` to be `LoadBalancer`. |
### How broadcast addresses reach ScyllaDB
1. The controller passes `--nodes-broadcast-address-type` and `--clients-broadcast-address-type` flags to both the **sidecar** and **ignition** containers.
2. At startup, the sidecar resolves the flag value to a concrete IP address by inspecting the pod status or the member Service.
3. The resolved addresses are passed to the ScyllaDB binary as `--broadcast-address` and `--broadcast-rpc-address` command-line arguments.
The ScyllaDB process itself listens on all interfaces (`0.0.0.0` for IPv4, `::` for IPv6). The broadcast addresses only control what address is advertised to other nodes and clients.
## Defaults
A `ScyllaCluster` created without explicit `exposeOptions` uses the following defaults:
| Field | Default |
|---------------------------------|--------------------|
| `nodeService.type` | `ClusterIP` |
| `broadcastOptions.nodes.type` | `ServiceClusterIP` |
| `broadcastOptions.clients.type` | `ServiceClusterIP` |
For multi-datacenter deployments using multiple `ScyllaCluster` resources connected via `externalSeeds`, you typically need to override these defaults to use `Headless` / `PodIP` so that pod IPs are broadcast directly. See the [Multi-VPC / multi-datacenter]() scenario below.
#### NOTE
`exposeOptions` on `ScyllaCluster` are **immutable** — they cannot be changed after the cluster is created.
## Common deployment scenarios
### In-cluster only (default)
```yaml
exposeOptions:
nodeService:
type: ClusterIP
broadcastOptions:
clients:
type: ServiceClusterIP
nodes:
type: ServiceClusterIP
```
Clients and nodes communicate through cluster-internal virtual IPs. The cluster is not reachable from outside Kubernetes.
### Pod IPs within a VPC
```yaml
exposeOptions:
nodeService:
type: ClusterIP
broadcastOptions:
clients:
type: PodIP
nodes:
type: ServiceClusterIP
```
Nodes talk to each other via ClusterIP (they share a Kubernetes cluster). Clients in the same VPC connect directly using pod IPs, which are routable within the VPC.
### Multi-VPC / multi-datacenter
```yaml
exposeOptions:
nodeService:
type: Headless
broadcastOptions:
clients:
type: PodIP
nodes:
type: PodIP
```
Two or more Kubernetes clusters in separate VPCs with VPC peering or a shared VPC. Each datacenter is a separate `ScyllaCluster` resource connected to the others via `externalSeeds`. Pod IPs are routable across VPCs, so both nodes and clients use them directly. No virtual IP is needed, hence Headless.
See [Deploy a multi-datacenter cluster](https://operator.docs.scylladb.com/stable/deploy-scylladb/deploy-multi-datacenter-cluster.md) for deployment guides.
### External access via load balancers
```yaml
exposeOptions:
nodeService:
type: LoadBalancer
broadcastOptions:
clients:
type: ServiceLoadBalancerIngress
nodes:
type: ServiceClusterIP
```
Each node gets a load balancer with an externally reachable address. Clients outside the cluster connect through the load balancer address. Nodes still communicate within the cluster via ClusterIP.
## IP families and dual-stack
The Operator supports IPv4, IPv6, and dual-stack networking. See [IPv6](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-networking/ipv6/index.md) for configuration details.
## Per-rack overrides
Each rack can override the labels and annotations on its member Services via `exposeOptions` at the rack level. This does not change the Service type — only metadata. It is useful for applying rack-specific load balancer annotations (for example, targeting a particular availability zone).
## No NetworkPolicy by default
The Operator does **not** create Kubernetes `NetworkPolicy` resources. If your environment requires network-level isolation, you must create NetworkPolicy objects separately. See [Security](https://operator.docs.scylladb.com/stable/understand/security.md) for related considerations.
## Related pages
- [Understand](https://operator.docs.scylladb.com/stable/understand/index.md) — component diagram and CRD summary.
- [Security](https://operator.docs.scylladb.com/stable/understand/security.md) — TLS certificates and authentication.
- [Sidecar](https://operator.docs.scylladb.com/stable/understand/sidecar.md) — how the sidecar resolves broadcast addresses at startup.
- [StatefulSets and racks](https://operator.docs.scylladb.com/stable/understand/statefulsets-and-racks.md) — StatefulSet naming and stable network identity.
# nodeconfigs.md
# NodeConfig (scylla.scylladb.com/v1alpha1)
**APIVersion**: scylla.scylladb.com/v1alpha1
**Kind**: NodeConfig
**PluralName**: nodeconfigs
**SingularName**: nodeconfig
**Scope**: Cluster
**ListKind**: NodeConfigList
**Served**: true
**Storage**: true
## Description
## Specification
| Property | Type | Description |
|--------------------------------------------------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| apiVersion | string | 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](https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources) |
| kind | string | 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](https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds) |
| [metadata](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-metadata) | object | |
| [spec](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec) | object | |
| [status](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-status) | object | |
### .metadata
#### Description
#### Type
object
### .spec
#### Description
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| disableOptimizations | boolean | disableOptimizations controls if nodes matching placement requirements are going to be optimized for performance. Turning off optimizations on already optimized Nodes does not revert changes. See [https://operator.docs.scylladb.com/stable/understand/tuning.html](https://operator.docs.scylladb.com/stable/understand/tuning.html) for details. |
| [localDiskSetup](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-localdisksetup) | object | localDiskSetup contains options of automatic local disk setup. |
| [placement](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement) | object | placement contains scheduling rules for NodeConfig Pods. |
| [sysctls](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-sysctls) | array (object) | sysctls specifies a list of sysctls to configure on the node. Removing parameters from this list does not revert already applied configurations. |
### .spec.localDiskSetup
#### Description
localDiskSetup contains options of automatic local disk setup.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------|
| [filesystems](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-localdisksetup-filesystems) | array (object) | filesystems is a list of filesystem configurations. |
| [loopDevices](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-localdisksetup-loopdevices) | array (object) | loops is a list of loop device configurations. |
| [mounts](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-localdisksetup-mounts) | array (object) | mounts is a list of mount configuration. |
| [raids](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-localdisksetup-raids) | array (object) | raids is a list of raid configurations. |
### .spec.localDiskSetup.filesystems[]
#### Description
FilesystemConfiguration specifies filesystem configuration options.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------|
| device | string | device is a path to the device where the desired filesystem should be created. |
| flags | array (string) | flags contains additional flags passed to the filesystem creation command. |
| type | string | type is a desired filesystem type. |
### .spec.localDiskSetup.loopDevices[]
#### Description
LoopDeviceConfiguration specifies loop device configuration options.
#### Type
object
| Property | Type | Description |
|------------|--------|----------------------------------------------------------------------------------------------------------|
| imagePath | string | imagePath specifies path on host where backing image file for loop device should be located. |
| name | string | name specifies the name of the symlink that will point to actual loop device, created under /dev/loops/. |
| size | | size specifies the size of the loop device. |
### .spec.localDiskSetup.mounts[]
#### Description
MountConfiguration specifies mount configuration options.
#### Type
object
| Property | Type | Description |
|--------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| device | string | device is path to a device that should be mounted. |
| fsType | string | fsType specifies the filesystem on the device. |
| mountPoint | string | mountPoint is a path where the device should be mounted at. If the mountPoint is a symlink, the mount will be set up for the target. |
| unsupportedOptions | array (string) | unsupportedOptions is a list of mount options used during device mounting. unsupported in this field name means that we won’t support all the available options passed down using this field. |
### .spec.localDiskSetup.raids[]
#### Description
RAIDConfiguration is a configuration of a raid array.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------|--------|-----------------------------------------------------------------------------|
| [RAID0](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-localdisksetup-raids-raid0) | object | RAID0 specifies RAID0 options. |
| name | string | name specifies the name of the raid device to be created under in /dev/md/. |
| type | string | type is a type of raid array. |
### .spec.localDiskSetup.raids[].RAID0
#### Description
RAID0 specifies RAID0 options.
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------|--------|----------------------------------------------------------|
| [devices](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-localdisksetup-raids-raid0-devices) | object | devices defines which devices constitute the raid array. |
### .spec.localDiskSetup.raids[].RAID0.devices
#### Description
devices defines which devices constitute the raid array.
#### Type
object
| Property | Type | Description |
|------------|--------|---------------------------------------------------------------------------|
| modelRegex | string | modelRegex is a regular expression filtering devices by their model name. |
| nameRegex | string | nameRegex is a regular expression filtering devices by their name. |
### .spec.placement
#### Description
placement contains scheduling rules for NodeConfig Pods.
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------|----------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [affinity](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity) | object | affinity is a group of affinity scheduling rules for NodeConfig Pods. |
| [nodeSelector](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-nodeselector) | object | nodeSelector is a selector which must be true for the NodeConfig Pod to fit on a node. Selector which must match a node’s labels for the pod to be scheduled on that node. |
| [tolerations](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-tolerations) | array (object) | tolerations is a group of tolerations NodeConfig Pods are going to have. |
### .spec.placement.affinity
#### Description
affinity is a group of affinity scheduling rules for NodeConfig Pods.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------|
| [nodeAffinity](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-nodeaffinity) | object | Describes node affinity scheduling rules for the pod. |
| [podAffinity](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podaffinity) | object | Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)). |
| [podAntiAffinity](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podantiaffinity) | object | Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)). |
### .spec.placement.affinity.nodeAffinity
#### Description
Describes node affinity scheduling rules for the pod.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [preferredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-nodeaffinity-preferredduringschedulingignoredduringexecution) | array (object) | 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. |
| [requiredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-nodeaffinity-requiredduringschedulingignoredduringexecution) | object | 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. |
### .spec.placement.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
#### 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).
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|-----------------------------------------------------------------------------------------|
| [preference](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-nodeaffinity-preferredduringschedulingignoredduringexecution-preference) | object | A node selector term, associated with the corresponding weight. |
| weight | integer | Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100. |
### .spec.placement.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference
#### Description
A node selector term, associated with the corresponding weight.
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-nodeaffinity-preferredduringschedulingignoredduringexecution-preference-matchexpressions) | array (object) | A list of node selector requirements by node’s labels. |
| [matchFields](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-nodeaffinity-preferredduringschedulingignoredduringexecution-preference-matchfields) | array (object) | A list of node selector requirements by node’s fields. |
### .spec.placement.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchExpressions[]
#### Description
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | The label key that the selector applies to. |
| operator | string | Represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. |
| values | array (string) | 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. |
### .spec.placement.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchFields[]
#### Description
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | The label key that the selector applies to. |
| operator | string | Represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. |
| values | array (string) | 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. |
### .spec.placement.affinity.nodeAffinity.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.
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------------|
| [nodeSelectorTerms](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-nodeaffinity-requiredduringschedulingignoredduringexecution-nodeselectorterms) | array (object) | Required. A list of node selector terms. The terms are ORed. |
### .spec.placement.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[]
#### 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.
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-nodeaffinity-requiredduringschedulingignoredduringexecution-nodeselectorterms-matchexpressions) | array (object) | A list of node selector requirements by node’s labels. |
| [matchFields](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-nodeaffinity-requiredduringschedulingignoredduringexecution-nodeselectorterms-matchfields) | array (object) | A list of node selector requirements by node’s fields. |
### .spec.placement.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchExpressions[]
#### Description
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | The label key that the selector applies to. |
| operator | string | Represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. |
| values | array (string) | 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. |
### .spec.placement.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchFields[]
#### Description
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | The label key that the selector applies to. |
| operator | string | Represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. |
| values | array (string) | 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. |
### .spec.placement.affinity.podAffinity
#### Description
Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [preferredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podaffinity-preferredduringschedulingignoredduringexecution) | array (object) | 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. |
| [requiredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podaffinity-requiredduringschedulingignoredduringexecution) | array (object) | 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. |
### .spec.placement.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
#### Description
The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|----------------------------------------------------------------------------------------|
| [podAffinityTerm](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm) | object | Required. A pod affinity term, associated with the corresponding weight. |
| weight | integer | weight associated with matching the corresponding podAffinityTerm, in the range 1-100. |
### .spec.placement.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
#### Description
Required. A pod affinity term, associated with the corresponding weight.
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [labelSelector](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector) | object | A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods. |
| matchLabelKeys | array (string) | MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key in (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn’t set. |
| mismatchLabelKeys | array (string) | MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key notin (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn’t set. |
| [namespaceSelector](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector) | object | 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. |
| namespaces | array (string) | 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”. |
| topologyKey | string | 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. |
### .spec.placement.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
#### Description
A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods.
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector-matchlabels) | object | 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. |
### .spec.placement.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.placement.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.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
### .spec.placement.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.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.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector-matchlabels) | object | 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. |
### .spec.placement.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.placement.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.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
### .spec.placement.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
#### 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
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [labelSelector](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podaffinity-requiredduringschedulingignoredduringexecution-labelselector) | object | A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods. |
| matchLabelKeys | array (string) | MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key in (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn’t set. |
| mismatchLabelKeys | array (string) | MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key notin (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn’t set. |
| [namespaceSelector](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podaffinity-requiredduringschedulingignoredduringexecution-namespaceselector) | object | 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. |
| namespaces | array (string) | 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”. |
| topologyKey | string | 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. |
### .spec.placement.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
#### Description
A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods.
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podaffinity-requiredduringschedulingignoredduringexecution-labelselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podaffinity-requiredduringschedulingignoredduringexecution-labelselector-matchlabels) | object | 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. |
### .spec.placement.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.placement.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.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
### .spec.placement.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].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.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podaffinity-requiredduringschedulingignoredduringexecution-namespaceselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podaffinity-requiredduringschedulingignoredduringexecution-namespaceselector-matchlabels) | object | 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. |
### .spec.placement.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.placement.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.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
### .spec.placement.affinity.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)).
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [preferredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podantiaffinity-preferredduringschedulingignoredduringexecution) | array (object) | 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 subtracting “weight” from the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. |
| [requiredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podantiaffinity-requiredduringschedulingignoredduringexecution) | array (object) | 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. |
### .spec.placement.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
#### Description
The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|----------------------------------------------------------------------------------------|
| [podAffinityTerm](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm) | object | Required. A pod affinity term, associated with the corresponding weight. |
| weight | integer | weight associated with matching the corresponding podAffinityTerm, in the range 1-100. |
### .spec.placement.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
#### Description
Required. A pod affinity term, associated with the corresponding weight.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [labelSelector](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector) | object | A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods. |
| matchLabelKeys | array (string) | MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key in (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn’t set. |
| mismatchLabelKeys | array (string) | MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key notin (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn’t set. |
| [namespaceSelector](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector) | object | 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. |
| namespaces | array (string) | 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”. |
| topologyKey | string | 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. |
### .spec.placement.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
#### Description
A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector-matchlabels) | object | 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. |
### .spec.placement.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.placement.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.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
### .spec.placement.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.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.
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector-matchlabels) | object | 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. |
### .spec.placement.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.placement.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.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
### .spec.placement.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
#### 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
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [labelSelector](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podantiaffinity-requiredduringschedulingignoredduringexecution-labelselector) | object | A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods. |
| matchLabelKeys | array (string) | MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key in (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn’t set. |
| mismatchLabelKeys | array (string) | MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key notin (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn’t set. |
| [namespaceSelector](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podantiaffinity-requiredduringschedulingignoredduringexecution-namespaceselector) | object | 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. |
| namespaces | array (string) | 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”. |
| topologyKey | string | 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. |
### .spec.placement.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
#### Description
A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podantiaffinity-requiredduringschedulingignoredduringexecution-labelselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podantiaffinity-requiredduringschedulingignoredduringexecution-labelselector-matchlabels) | object | 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. |
### .spec.placement.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.placement.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.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
### .spec.placement.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].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.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podantiaffinity-requiredduringschedulingignoredduringexecution-namespaceselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-spec-placement-affinity-podantiaffinity-requiredduringschedulingignoredduringexecution-namespaceselector-matchlabels) | object | 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. |
### .spec.placement.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.placement.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.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
### .spec.placement.nodeSelector
#### Description
nodeSelector is a selector which must be true for the NodeConfig Pod to fit on a node. Selector which must match a node’s labels for the pod to be scheduled on that node.
#### Type
object
### .spec.placement.tolerations[]
#### Description
The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .
#### Type
object
| Property | Type | Description |
|-------------------|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| effect | string | Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute. |
| key | string | 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. |
| operator | string | Operator represents a key’s relationship to the value. Valid operators are Exists, Equal, Lt, and Gt. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. Lt and Gt perform numeric comparisons (requires feature gate TaintTolerationComparisonOperators). |
| tolerationSeconds | integer | 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. |
| value | string | Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string. |
### .spec.sysctls[]
#### Description
Sysctl defines a kernel parameter to be set
#### Type
object
| Property | Type | Description |
|------------|--------|----------------------------|
| name | string | Name of a property to set |
| value | string | Value of a property to set |
### .status
#### Description
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------|
| [conditions](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-status-conditions) | array (object) | conditions represents the latest available observations of current state. |
| [nodeStatuses](#api-scylla-scylladb-com-nodeconfigs-v1alpha1-status-nodestatuses) | array (object) | nodeStatuses hold the status for each tuned node. |
| observedGeneration | integer | observedGeneration indicates the most recent generation observed by the controller. |
### .status.conditions[]
#### Description
#### Type
object
| Property | Type | Description |
|--------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| lastTransitionTime | string | lastTransitionTime is last time the condition transitioned from one status to another. |
| message | string | message is a human-readable message indicating details about the transition. |
| observedGeneration | integer | observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance. |
| reason | string | reason is the reason for condition’s last transition. |
| status | string | status represents the state of the condition, one of True, False, or Unknown. |
| type | string | type is the type of the NodeConfig condition. |
### .status.nodeStatuses[]
#### Description
#### Type
object
| Property | Type | Description |
|-----------------|----------------|---------------|
| name | string | |
| tunedContainers | array (string) | |
| tunedNode | boolean | |
# nodetool-alternatives.md
# nodetool alternatives
This page is for ScyllaDB administrators transitioning to Kubernetes. It explains why direct `nodetool` operations that change cluster state must not be used with the Operator, and what to do instead.
#### NOTE
ScyllaDB’s `nodetool` is a distinct implementation from Apache Cassandra’s — it communicates with ScyllaDB via the [REST API](https://docs.scylladb.com/manual/stable/operating-scylla/rest.html) (not JMX), though many command names are the same.
## Why this matters
The Operator reconciles cluster state continuously. Any out-of-band change to cluster membership or topology creates a mismatch between the Operator’s expected state and reality, leading to stuck rollouts, failed replacements, or data loss.
## Read-only commands are always safe
If a `nodetool` command is read-only, it is always safe to use via `kubectl exec`. Examples:
[`status`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/status.html), [`gossipinfo`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/gossipinfo.html), [`info`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/info.html), [`ring`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/ring.html), [`cfstats`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/cfstats.html) / [`tablestats`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/tablestats.html), [`compactionstats`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/compactionstats.html), [`toppartitions`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/toppartitions.html)
```shell
kubectl exec -it -c scylla -- nodetool status
```
## State-changing commands
If a command changes cluster state, consult the table below.
### High risk — use Operator alternatives
#### WARNING
These operations are irreversible and may cause data loss or cluster instability if performed on an unhealthy cluster.
Back up your data before proceeding.
These commands change cluster membership or topology. Using them directly will desync the Operator’s state.
| Command | Risk | Operator alternative |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [`decommission`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/decommission.html) | Desyncs StatefulSet replica count and Operator tracking labels. Operator will not know the node was decommissioned. | Scale down the rack’s `members` count by 1. The Operator labels the service, the sidecar calls decommission, and the StatefulSet scales down after completion. See [Scale, add, remove racks](https://operator.docs.scylladb.com/stable/operate/scale-add-remove-racks.md). |
| [`removenode`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/removenode.html) | Removes a node from the ring without Operator knowledge. Operator expects to manage membership via scale-down or replace. | Use the `scylla/replace` label on the member Service to trigger Operator-managed replacement. For dead nodes, see [Recover from failed replace](https://operator.docs.scylladb.com/stable/troubleshoot/recover-from-failed-replace.md). |
| `move` | Changes token ownership without Operator awareness. | Not supported. Use scaling (add/remove nodes) to rebalance. |
| [`rebuild`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/rebuild.html) | Streams data from another datacenter; Operator does not track rebuild state. Running during an Operator-managed operation can cause conflicts. | No Operator alternative. If rebuild is needed (for example, adding a new DC), coordinate manually — ensure no other operations are in progress. |
| [`disablebinary`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/disablebinary.html) / [`enablebinary`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/enablebinary.html) | Disabling native transport makes the node unreachable to clients and may cause readiness probe failures, triggering Operator recovery actions. | Do not use. If you need to stop traffic to a node, use [maintenance mode](https://operator.docs.scylladb.com/stable/operate/use-maintenance-mode.md). |
| [`disablegossip`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/disablegossip.html) / [`enablegossip`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/enablegossip.html) | Disabling gossip effectively marks the node as down in the cluster, confusing the Operator’s health checks and potentially triggering unwanted recovery. | Do not use. |
### Medium risk — automatic or use with caution
| Command | Risk | Operator alternative |
|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------|
| [`drain`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/drain.html) | Puts node in DRAINED state; sidecar may restart ScyllaDB if a decommission is pending. | Automatic — drain runs as a `preStop` lifecycle hook before every pod shutdown. No manual invocation needed. |
| [`disableautocompaction`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/disableautocompaction.html) / [`enableautocompaction`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/enableautocompaction.html) | Ephemeral change, but disabling auto-compaction can cause unbounded SSTable growth if forgotten. Operator does not track this state. | No Operator alternative. Use with caution and re-enable promptly. |
| [`stop`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/stop.html) (compaction) | Stops in-progress compaction. Safe but may need to be repeated if compaction restarts. | No Operator alternative. Use with caution. |
### Low risk — safe to use
These commands are safe to use directly. The Operator either handles them automatically or does not conflict with them.
| Command | Notes | Operator alternative |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [`repair`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/repair.html) | Safe to run manually but redundant. | Configure repair tasks via ScyllaDB Manager (managed through the ScyllaCluster spec). Manager handles scheduling and distributed coordination. |
| [`cleanup`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/cleanup.html) | Safe and idempotent, but the Operator runs cleanup automatically when it detects token ring changes. | Automatic — the Operator tracks token ring hash changes per service and spawns cleanup Jobs when they diverge. Manual cleanup is only needed after replication factor changes (which the Operator does not detect). |
| [`snapshot`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/snapshot.html) / [`clearsnapshot`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/clearsnapshot.html) | Safe to use. | No Operator alternative; for scheduled backups, use ScyllaDB Manager backup tasks. |
| [`compact`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/compact.html) | Safe to trigger manually. | No Operator alternative; manual compaction is acceptable. |
| [`flush`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/flush.html) | Safe to trigger manually. | No Operator alternative; flushing memtables is acceptable. |
| [`scrub`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/scrub.html) | Safe to trigger manually. | No Operator alternative; manual scrub is acceptable. |
| [`setlogginglevel`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/setlogginglevel.html) | Ephemeral change, lost on pod restart. Safe for live debugging. | Preferred method for emergency log-level changes when a rolling restart is not possible. See [Change log level](https://operator.docs.scylladb.com/stable/troubleshoot/change-log-level.md). For persistent changes, use the ScyllaCluster spec — see [Pass ScyllaDB arguments](https://operator.docs.scylladb.com/stable/operate/pass-scylladb-arguments.md). |
| [`refresh`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/refresh.html) | Loads SSTables placed on disk; does not affect cluster membership. | No Operator alternative; safe to use. |
| [`upgradesstables`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/upgradesstables.html) | Rewrites SSTables to the latest format; safe but resource-intensive. | No Operator alternative; safe to use, typically needed after a ScyllaDB version upgrade. |
| [`setcompactionthroughput`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/setcompactionthroughput.html) / [`setstreamthroughput`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/setstreamthroughput.html) | Ephemeral tuning changes, lost on restart. | No Operator alternative; safe to use for temporary tuning. For persistent changes, configure via the ScyllaCluster spec. |
| [`settraceprobability`](https://docs.scylladb.com/manual/stable/operating-scylla/nodetool-commands/settraceprobability.html) | Ephemeral diagnostic setting. | No Operator alternative; safe to use for debugging. |
## Related pages
- [StatefulSets and racks](https://operator.docs.scylladb.com/stable/understand/statefulsets-and-racks.md) — how the Operator maps ScyllaDB topology onto Kubernetes primitives.
- [Scale, add, remove racks](https://operator.docs.scylladb.com/stable/operate/scale-add-remove-racks.md) — adding and removing nodes via the Operator.
- [Replace nodes](https://operator.docs.scylladb.com/stable/operate/replace-nodes.md) — Operator-managed node replacement.
- [Automatic data cleanup](https://operator.docs.scylladb.com/stable/understand/automatic-data-cleanup.md) — how the Operator handles post-scaling cleanup.
# pass-scylladb-arguments.md
# Pass additional ScyllaDB arguments
Pass extra command-line arguments to the ScyllaDB binary at startup to tune behaviour or enable features that are not exposed through the ScyllaDB configuration files.
## How it works
The Operator appends the additional arguments to the ScyllaDB binary command line when starting each pod.
Because the arguments are part of the pod spec (via the StatefulSet), changing them triggers a **rolling restart** of all nodes in the cluster — each node is updated one at a time.
## ScyllaCluster (v1 API)
Set `spec.scyllaArgs` to a string of additional arguments:
```yaml
apiVersion: scylla.scylladb.com/v1
kind: ScyllaCluster
metadata:
name: scylla
namespace: scylla
spec:
scyllaArgs: "--blocked-reactor-notify-ms 10"
datacenter:
name: us-east-1
racks:
- name: us-east-1a
members: 3
storage:
capacity: 500Gi
resources:
limits:
cpu: 4
memory: 8Gi
```
#### NOTE
In the v1 API, `scyllaArgs` is a single string.
Multiple arguments are separated by spaces.
#### NOTE
Due to a technical limitation, arguments are represented internally as key-value pairs.
Only flags that take a value are supported (e.g. `--blocked-reactor-notify-ms 500`).
For boolean flags, pass `1` (true) or `0` (false) as the value — for example, `--developer-mode 0`.
## Verify
After the rolling restart completes, confirm that the arguments were applied to the ScyllaDB container.
**Check the pod spec:**
```bash
kubectl -n scylla get pod -o jsonpath='{.spec.containers[?(@.name=="scylla")].command}'
```
The arguments appear in the ScyllaDB container’s command alongside other default arguments added by the Operator.
**Check the ScyllaDB startup logs:**
```bash
kubectl -n scylla logs -c scylla | head -20
```
The ScyllaDB startup line will include the configured arguments alongside the other flags passed to the binary.
## Emergency log level changes
When a rolling restart is not possible — for example, during a stuck rollout or with a degraded cluster — use the ScyllaDB REST API to change settings on running pods without a restart. See [Change the log level](https://operator.docs.scylladb.com/stable/troubleshoot/change-log-level.md).
## Related pages
- [Perform a rolling restart](https://operator.docs.scylladb.com/stable/operate/perform-rolling-restart.md) — how the Operator performs rolling restarts when the pod spec changes
- [Changing the log level](https://operator.docs.scylladb.com/stable/troubleshoot/change-log-level.md) — adjusting ScyllaDB runtime settings without a restart
# perform-rolling-restart.md
# Perform a rolling restart
Force a rolling restart of all ScyllaDB nodes in a cluster by changing the `forceRedeploymentReason` field.
## How it works
The Operator places `forceRedeploymentReason` as an annotation on the StatefulSet pod template.
When you change the value, the pod template changes, which triggers the StatefulSet controller to perform a rolling update.
The Operator orchestrates this update one pod at a time, draining each node before terminating it and waiting for the replacement to become ready before proceeding to the next.
The value itself is arbitrary — it only needs to be different from the previous value.
Using a descriptive string (e.g. `"config change 2024-01-15"`) makes it easier to identify why a restart was triggered.
## Restart a ScyllaCluster
Patch the `spec.forceRedeploymentReason` field:
```bash
kubectl -n scylla patch scyllacluster/scylla --type=merge \
-p='{"spec": {"forceRedeploymentReason": "restart-2024-01-15"}}'
```
Wait for the rolling restart to complete:
```bash
kubectl -n scylla wait --timeout=30m --for='condition=Progressing=False' scyllaclusters.scylla.scylladb.com/scylla
kubectl -n scylla wait --timeout=30m --for='condition=Degraded=False' scyllaclusters.scylla.scylladb.com/scylla
kubectl -n scylla wait --timeout=30m --for='condition=Available=True' scyllaclusters.scylla.scylladb.com/scylla
```
#### NOTE
In multi-DC clusters using multiple `ScyllaCluster` resources, restart each datacenter’s `ScyllaCluster` independently.
## Key considerations
| Consideration | Detail |
|------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| One at a time | The Operator restarts one node at a time per rack. Each node is drained before termination, and the replacement must be ready before the next node is restarted. |
| Unique value | The value of `forceRedeploymentReason` must be different from the current value to trigger a restart. Repeating the same string has no effect. |
| Impact on availability | A rolling restart temporarily reduces the number of available replicas by one. Ensure your replication factor allows for one node to be unavailable. |
| PodDisruptionBudget | The PDB (`maxUnavailable: 1`) ensures that at most one node per datacenter is unavailable at any given time, even during a rolling restart. |
## Related pages
- [StatefulSets and racks](https://operator.docs.scylladb.com/stable/understand/statefulsets-and-racks.md) — how StatefulSets manage rolling updates with partition-based rollouts
- [Upgrade ScyllaDB](https://operator.docs.scylladb.com/stable/upgrade/upgrade-scylladb.md) — version upgrades that include an automatic rolling restart
# pod-disruption-budgets.md
# Pod disruption budgets
This page explains how ScyllaDB Operator uses Kubernetes PodDisruptionBudgets (PDBs) to protect ScyllaDB availability during voluntary disruptions.
## What a PDB does
A [PodDisruptionBudget](https://kubernetes.io/docs/concepts/workloads/pods/disruptions/#pod-disruption-budgets) limits how many pods matching a selector can be voluntarily evicted at the same time. Voluntary disruptions include:
- Kubernetes node drains (maintenance, upgrades).
- Cluster autoscaler scale-down.
- Manual pod evictions via the Eviction API.
PDBs do **not** protect against involuntary disruptions such as hardware failures or OOM kills.
## ScyllaDB cluster PDB
The Operator creates one PDB per ScyllaDB datacenter with:
```yaml
spec:
maxUnavailable: 1
```
This ensures that **at most one ScyllaDB node** can be voluntarily disrupted at a time across the entire datacenter. The Kubernetes API server blocks eviction requests that would violate this budget.
### Excluding cleanup Jobs
The PDB selector uses the same labels as the ScyllaDB pods but adds a `MatchExpression` that excludes pods with the `batch.kubernetes.io/job-name` label. Kubernetes automatically adds this label to every pod created by a Job. This means cleanup Job pods (see [Automatic data cleanup](https://operator.docs.scylladb.com/stable/understand/automatic-data-cleanup.md)) do not count toward the PDB budget and cannot block node drains.
## Operator and webhook PDBs
The Operator deployment and the webhook server deployment each have their own PDB:
| Component | PDB spec | When created |
|-------------------|-------------------|-----------------------------------------|
| `scylla-operator` | `minAvailable: 1` | When running with more than one replica |
| `webhook-server` | `minAvailable: 1` | When running with more than one replica |
These PDBs ensure that at least one Operator pod and one webhook pod remain available during node drains, preventing a complete loss of the control plane during cluster maintenance.
## PDB interaction with operations
### Rolling updates
The Operator uses a **partition-based rollout** strategy for StatefulSets. During an upgrade:
1. All StatefulSets are partitioned at their current replica count, preventing any pod from restarting.
2. The partition is decremented by one, allowing a single pod to pick up the new template and restart.
3. The controller waits for the restarted pod to become ready before decrementing the partition again.
4. Only one rack makes progress per reconciliation cycle.
This one-at-a-time rollout naturally respects the `maxUnavailable: 1` PDB because at most one pod is unavailable during each step.
### Scale-down
When scaling down, the Operator decommissions one member at a time. The SidecarController drives the decommission process inside each pod. Because only one pod is being removed at a time, the PDB is not violated.
### Node replacement
Node replacement follows a similar pattern — one node is replaced at a time. The PDB prevents the Kubernetes scheduler from evicting additional ScyllaDB pods while a replacement is in progress.
### Kubernetes node drains
When a Kubernetes node is drained (for example, during a Kubernetes upgrade), the drain process evicts pods through the Eviction API, which respects PDBs. If the ScyllaDB cluster already has one node unavailable (due to a concurrent operation or failure), the PDB blocks further evictions until the first node recovers.
## Related pages
- [Statefulsets and racks](https://operator.docs.scylladb.com/stable/understand/statefulsets-and-racks.md) — rolling update strategy and partition-based rollout.
- [Understand](https://operator.docs.scylladb.com/stable/understand/index.md) — reconciliation model.
# production-checklist.md
# Production checklist
This page provides a checklist of settings and configurations to verify before running ScyllaDB in production on Kubernetes.
## Checklist
| # | Item | Expected state | Guide |
|-----|--------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------|
| 1 | **NodeConfig deployed** | A `NodeConfig` resource is applied and `Available=True` in each cluster running ScyllaDB. NodeConfig configures disk setup, kernel parameters, and performance tuning — without it, ScyllaDB runs on untuned nodes with default kernel settings. | [Node configuration](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/configure-nodes.md) |
| 2 | **Dedicated node pool** | ScyllaDB runs on isolated nodes with label `scylla.scylladb.com/node-type=scylla` and taint `scylla-operator.scylladb.com/dedicated=scyllaclusters:NoSchedule`. No other workloads are scheduled on these nodes. | [Set up dedicated node pools](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/set-up-dedicated-node-pools.md) |
| 3 | **Performance tuning co-located** | NodeConfig `placement` targets the same nodes as the ScyllaCluster placement. Both use the same label selector and toleration. If they target different node sets, tuning does not apply to ScyllaDB pods. | [Set up dedicated node pools](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/set-up-dedicated-node-pools.md) |
| 4 | **`fs.nr_open` set** | The sysctl `fs.nr_open` is set to a high value (e.g., `1073741816`) via NodeConfig. This defines the ceiling for `RLIMIT_NOFILE`, which ScyllaDB Operator raises on each ScyllaDB process. Without it, ScyllaDB may fail to open files under heavy load. | [Configure nodes](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/configure-nodes.md) |
| 5 | **Coredumps enabled** | `systemd-coredump` is configured on the host with sufficient backing storage. Coredumps are essential for diagnosing crashes. | [Coredumps](https://operator.docs.scylladb.com/stable/troubleshoot/configure-coredumps.md) |
| 6 | **Monitoring deployed** | A `ScyllaDBMonitoring` resource is created with Prometheus scraping ScyllaDB metrics and Grafana displaying dashboards. Alerts are configured for key failure modes. | [Set up monitoring](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-monitoring/index.md) |
| 7 | **Resource requests and limits set** | Both `resources` (ScyllaDB container) and `agentResources` (Manager Agent sidecar) have explicit requests and limits. ScyllaDB derives its memory allocation from the container memory limit. Ensure values match your instance type and workload. | [Deploy your first cluster](https://operator.docs.scylladb.com/stable/deploy-scylladb/deploy-your-first-cluster.md) |
| 8 | **CPU pinning active** | The kubelet uses `cpuManagerPolicy: static`. The ScyllaDB pod has Guaranteed QoS class (requests equal limits for all containers). ScyllaDB starts with `--overprovisioned=0`. | [Configure CPU pinning](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/configure-cpu-pinning.md) |
| 9 | **XFS online discard enabled** | The `discard` mount option is set on ScyllaDB data volumes via NodeConfig’s `unsupportedOptions`. This enables SSD TRIM for consistent write performance. | [Configure nodes](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/configure-nodes.md) |
| 10 | **I/O properties configured** | Precomputed I/O properties are set to avoid the automatic I/O benchmark that runs on first boot, which can produce inconsistent results in cloud environments. | [Configure precomputed IO properties](https://operator.docs.scylladb.com/stable/operate/configure-io-properties.md) |
| 11 | **Backups scheduled** | ScyllaDB Manager backup tasks are configured with object storage (S3, GCS, or Azure Blob) and appropriate IAM credentials. Backup schedules are tested with a restore drill. | [Back up and restore](https://operator.docs.scylladb.com/stable/operate/back-up-and-restore.md) |
## Verification commands
Run these commands to quickly check the most critical items:
### NodeConfig status
```shell
kubectl get nodeconfigs.scylla.scylladb.com -o wide
```
All NodeConfig resources should show `AVAILABLE=True`, `PROGRESSING=False`, `DEGRADED=False`.
### Pod QoS class
```shell
kubectl get pods -l scylla/cluster=scylladb -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.status.qosClass}{"\n"}{end}'
```
All pods should show `Guaranteed`.
### ScyllaDB startup flags
```shell
kubectl logs -c scylla | grep overprovisioned
```
Expected: `--overprovisioned=0`
### Monitoring status
```shell
kubectl get scylladbmonitoring -o wide
```
Should show `AVAILABLE=True`.
## Related pages
- [Deploy your first cluster](https://operator.docs.scylladb.com/stable/deploy-scylladb/deploy-your-first-cluster.md) — creating a ScyllaCluster.
- [Configure nodes](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/configure-nodes.md) — disk setup, sysctls, and performance tuning.
- [Configure CPU pinning](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/configure-cpu-pinning.md) — configuring CPU exclusivity.
- [Set up monitoring](https://operator.docs.scylladb.com/stable/deploy-scylladb/set-up-monitoring/index.md) — Prometheus and Grafana setup.
# recover-from-failed-replace.md
# Recover from a failed node replace
Step-by-step procedure to recover when a node replace operation fails and leaves ScyllaDB Operator stuck.
#### WARNING
This procedure involves manual cluster-state manipulation and can cause data loss on the affected node.
Follow each step carefully and collect a must-gather archive before making any destructive changes.
## When to use this procedure
Use this guide when:
- A node replace is stuck — the replacement pod is in `CrashLoopBackOff` or stuck joining.
- `nodetool status` shows a node with status `DN` or `?N` that was being replaced.
- ScyllaDB Operator cannot apply further configuration changes because the rollout is blocked.
This guide assumes that all other nodes in the cluster are healthy (`UN`).
For normal node replacement, see [Replace nodes](https://operator.docs.scylladb.com/stable/operate/replace-nodes.md).
## Prerequisites
- `kubectl` access to the cluster.
- Ability to scale the ScyllaDB Operator Deployment.
- A recent backup — this is a dangerous operation and a data backup is recommended before proceeding.
## Verify the failure
Run `nodetool status` on a healthy node to confirm the stuck state:
```console
$ kubectl -n exec -c scylla -- nodetool status
Datacenter: exampledc
=====================
Status=Up/Down
|/ State=Normal/Leaving/Joining/Moving
-- Address Load Tokens Owns Host ID Rack
UN 10.152.183.112 491.57 KB 256 ? e7478c73-07a9-4fb2-a435-6603ccc9e6bd examplerack
DN 10.152.183.214 466.12 KB 256 ? 09d815de-6f6d-4394-8439-bd8d34231835 examplerack
UN 10.152.183.43 456.25 KB 256 ? ac4e578d-cc82-4b71-9ba1-0f40aede9e8d examplerack
```
Ensure that the culprit entry matches either the old (replaced) node’s Host ID or the new (attempting to replace) node’s Host ID. Check the logs of the failing pod to determine which one it is.
## Collect a must-gather archive
Before making any changes, capture the current state by collecting a must-gather archive.
See [Collect debugging information](https://operator.docs.scylladb.com/stable/troubleshoot/collect-debugging-information/index.md) for instructions.
## Pause ScyllaDB Operator
Note the current replica count, then scale ScyllaDB Operator to zero to prevent reconciliation while you perform manual recovery:
```bash
# Note the current replicas (typically 2)
kubectl -n scylla-operator get deploy scylla-operator -o jsonpath='{.spec.replicas}'
# Scale to zero
kubectl -n scylla-operator scale deploy/scylla-operator --replicas=0 --timeout=5m
```
Wait for ScyllaDB Operator pods to terminate:
```bash
kubectl -n scylla-operator get pods -w
```
## Orphan-delete the rack StatefulSet
Delete the StatefulSet for the affected rack **without deleting its pods**.
This prevents the StatefulSet from recreating the culprit pod when you delete it in the next step.
ScyllaDB Operator will recreate the StatefulSet in its exact form when it resumes.
```bash
kubectl -n delete statefulset -- --cascade=orphan
```
#### WARNING
You **must** use `--cascade=orphan`.
Without this flag, `kubectl delete statefulset` also deletes all pods managed by the StatefulSet, causing unavailability for that rack.
Deletion of a StatefulSet does not delete associated PVCs, so even if you accidentally omit `--cascade=orphan`, data is preserved on the PVCs and Operator will recover the pods when it resumes.
The existing pods continue running.
## Identify Host IDs to remove
Run `nodetool status` and note the Host IDs of:
- The **culprit node** (the failed replacement).
- Any **ghost members** — nodes that appear in the ring but have no corresponding running pod.
```bash
kubectl -n exec -c scylla -- nodetool status
```
## Stop the culprit node
Delete the pod, PVC, and Service for the failed node:
```bash
# Stop the node that is failing to join the cluster.
# The StatefulSet does not exist, so it will not recreate the pod.
kubectl -n delete pod
# WARNING: This causes data loss for this node.
# Delete the PersistentVolumeClaim for the data volume held by the culprit node.
kubectl -n delete pvc
# Delete the per-node Service.
# ScyllaDB Operator interprets this as a need to provision a brand-new node
# instead of attempting to replace the old one in the rack.
kubectl -n delete service
```
## Remove ghost members
For each ghost Host ID, run `nodetool removenode` from a healthy node:
```bash
kubectl -n exec -c scylla -- nodetool removenode
```
Repeat as necessary for each ghost member.
Verify that only healthy nodes remain:
```console
$ kubectl -n exec -c scylla -- nodetool status
Datacenter: exampledc
=====================
Status=Up/Down
|/ State=Normal/Leaving/Joining/Moving
-- Address Load Tokens Owns Host ID Rack
UN 10.152.183.112 491.57 KB 256 ? e7478c73-07a9-4fb2-a435-6603ccc9e6bd examplerack
UN 10.152.183.43 456.25 KB 256 ? ac4e578d-cc82-4b71-9ba1-0f40aede9e8d examplerack
```
All remaining nodes should show `UN`.
## Resume ScyllaDB Operator
Scale ScyllaDB Operator back to its original replica count:
```bash
# Replace N with the number of replicas noted earlier (typically 2).
kubectl -n scylla-operator scale deploy/scylla-operator --replicas= --timeout=5m
```
ScyllaDB Operator will:
1. Recreate the (identical) StatefulSet for the rack.
2. Recreate the per-node Service.
3. Create a new Pod and PVC for the removed node.
4. The new node joins the cluster as a fresh member and streams data from peers.
## Verify recovery
Wait for the new pod to become ready:
```bash
kubectl -n get pods -w
```
Verify cluster health:
```console
$ kubectl -n exec -c scylla -- nodetool status
Datacenter: exampledc
=====================
Status=Up/Down
|/ State=Normal/Leaving/Joining/Moving
-- Address Load Tokens Owns Host ID Rack
UN 10.152.183.112 491.57 KB 256 ? e7478c73-07a9-4fb2-a435-6603ccc9e6bd examplerack
UN 10.152.183.234 493.66 KB 256 ? NEW-UUID-DIFFERENT-THAN-BEFORE-abcde examplerack
UN 10.152.183.43 456.25 KB 256 ? ac4e578d-cc82-4b71-9ba1-0f40aede9e8d examplerack
```
All nodes should show `UN`. Note that the recovered node has a new Host ID.
## Multi-datacenter note
In a multi-datacenter deployment using multiple `ScyllaCluster` resources, perform this procedure in the Kubernetes cluster hosting the failed node’s datacenter.
## What if something goes wrong
| Situation | Recovery |
|-------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Accidentally deleted StatefulSet without `--cascade=orphan` | Pods are deleted (causing rack unavailability), but PVCs survive. When ScyllaDB Operator resumes and recreates the StatefulSet, new pods are created and reattach to existing PVCs. Data is preserved. |
| ScyllaDB Operator fails to recreate the StatefulSet | Manually recreate it from the must-gather archive (the StatefulSet YAML is captured). |
| New node fails to join | Repeat the procedure — verify that all ghost members were removed. Check seed configuration and network connectivity. |
## Related pages
- [Replace nodes](https://operator.docs.scylladb.com/stable/operate/replace-nodes.md)
- [StatefulSets and racks](https://operator.docs.scylladb.com/stable/understand/statefulsets-and-racks.md)
- [Collect debugging information](https://operator.docs.scylladb.com/stable/troubleshoot/collect-debugging-information/index.md)
# reference-deployment-eks.md
# Reference deployment: EKS
This guide deploys a production-ready ScyllaDB cluster on Amazon Elastic Kubernetes Service (EKS).
By the end, you will have a 3-node ScyllaDB cluster spread across 3 availability zones, with performance tuning and local NVMe storage configured.
## Prerequisites
- An EKS cluster provisioned with a dedicated ScyllaDB node group with local NVMe SSDs.
If you do not have one yet, follow [Set up an EKS cluster for ScyllaDB](https://operator.docs.scylladb.com/stable/install-operator/provision-infrastructure/set-up-eks-cluster.md).
- Dedicated nodes labeled and tainted per [Set up dedicated node pools](https://operator.docs.scylladb.com/stable/deploy-scylladb/before-you-deploy/set-up-dedicated-node-pools.md).
The EKS cluster setup guide handles this automatically.
- ScyllaDB Operator installed.
Follow [Install ScyllaDB Operator](https://operator.docs.scylladb.com/stable/install-operator/install-with-gitops.md) if you have not done so yet.
- [`kubectl`](https://kubernetes.io/docs/tasks/tools/#kubectl) configured and pointed at the cluster.
- The environment variables from the [EKS cluster setup guide](https://operator.docs.scylladb.com/stable/install-operator/provision-infrastructure/set-up-eks-cluster.md#set-environment-variables) exported in your shell (at minimum `AWS_REGION`, `EKS_AZ_1`, `EKS_AZ_2`, `EKS_AZ_3`).
## Work around the ScyllaDB utils image issue
The default ScyllaDB utils image used by the operator for node tuning jobs contains a broken `systemctl` binary that fails on EKS nodes running `irqbalance`.
Until this is fixed upstream, override the utils image with an older version that includes a working `systemctl`:
```console
kubectl apply --server-side -f=- <[1](#scylladb-monitoring-version) |
### Third-party dependencies
The following table lists the versions of third-party dependencies that ScyllaDB Operator is tested against.
| Component | Version |
|---------------------|-----------|
| cert-manager | 1.21.1 |
| Grafana | 12.4.6 |
| Prometheus | 3.12.0 |
| Prometheus Operator | 0.93.1 |
### Architectures
ScyllaDB Operator image is published as a manifest list to `docker.io/scylladb/scylla-operator:X.Y.Z` containing image build for `amd64` and `aarch64`.
### Supported Kubernetes environments
We officially test and recommend to use the following environments:
| Platform | OS Image |
|------------|--------------|
| GKE | Ubuntu |
| EKS | Amazon Linux |
| OKE | Oracle Linux |
While our APIs generally work on any Kubernetes conformant cluster,
performance tuning and other pieces that need to interact with the host OS, kubelet, CRI, kernel, etc. might hit some incompatibilities.
#### WARNING
The following environments are known **not to work correctly** at this time.
| Platform | OS Image | Details |
|------------|--------------|------------------------------------------------------------------------------------|
| GKE | Container OS | Lack of XFS support |
| EKS | Bottlerocket | Suspected kernel/cgroups issue that breaks available memory detection for ScyllaDB |
---
* **[1]** ScyllaDB Operator embeds the specified version of ScyllaDB Monitoring, which includes a set of Grafana dashboards and Prometheus rules.
# remotekubernetesclusters.md
# RemoteKubernetesCluster (scylla.scylladb.com/v1alpha1)
**APIVersion**: scylla.scylladb.com/v1alpha1
**Kind**: RemoteKubernetesCluster
**PluralName**: remotekubernetesclusters
**SingularName**: remotekubernetescluster
**Scope**: Cluster
**ListKind**: RemoteKubernetesClusterList
**Served**: true
**Storage**: true
## Description
## Specification
| Property | Type | Description |
|---------------------------------------------------------------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| apiVersion | string | 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](https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources) |
| kind | string | 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](https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds) |
| [metadata](#api-scylla-scylladb-com-remotekubernetesclusters-v1alpha1-metadata) | object | |
| [spec](#api-scylla-scylladb-com-remotekubernetesclusters-v1alpha1-spec) | object | spec defines the desired state of the RemoteKubernetesCluster. |
| [status](#api-scylla-scylladb-com-remotekubernetesclusters-v1alpha1-status) | object | status defines the observed state of the RemoteKubernetesCluster. |
### .metadata
#### Description
#### Type
object
### .spec
#### Description
spec defines the desired state of the RemoteKubernetesCluster.
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------------------|--------|---------------------------------------------------------------------------------------------------------------------|
| [clientHealthcheckProbes](#api-scylla-scylladb-com-remotekubernetesclusters-v1alpha1-spec-clienthealthcheckprobes) | object | healthcheckProbes hold client healthcheck probes settings. |
| [kubeconfigSecretRef](#api-scylla-scylladb-com-remotekubernetesclusters-v1alpha1-spec-kubeconfigsecretref) | object | kubeconfigSecretRef is a reference to a secret keeping kubeconfig allowing to connect to remote Kubernetes cluster. |
### .spec.clientHealthcheckProbes
#### Description
healthcheckProbes hold client healthcheck probes settings.
#### Type
object
| Property | Type | Description |
|---------------|---------|------------------------------------------------------------------|
| periodSeconds | integer | periodSeconds specifies the period of client healthcheck probes. |
### .spec.kubeconfigSecretRef
#### Description
kubeconfigSecretRef is a reference to a secret keeping kubeconfig allowing to connect to remote Kubernetes cluster.
#### Type
object
| Property | Type | Description |
|------------|--------|--------------------------------------------------------------------------|
| name | string | name is unique within a namespace to reference a secret resource. |
| namespace | string | namespace defines the space within which the secret name must be unique. |
### .status
#### Description
status defines the observed state of the RemoteKubernetesCluster.
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------|----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [conditions](#api-scylla-scylladb-com-remotekubernetesclusters-v1alpha1-status-conditions) | array (object) | conditions hold conditions describing RemoteKubernetesCluster state. |
| observedGeneration | integer | observedGeneration is the most recent generation observed for this RemoteKubernetesCluster. It corresponds to the RemoteKubernetesCluster’s generation, which is updated on mutation by the API Server. |
### .status.conditions[]
#### Description
Condition contains details for one aspect of the current state of this API Resource.
#### Type
object
| Property | Type | Description |
|--------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| lastTransitionTime | string | lastTransitionTime is the last time the condition transitioned from one status to another. This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. |
| message | string | message is a human readable message indicating details about the transition. This may be an empty string. |
| observedGeneration | integer | observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance. |
| reason | string | reason contains a programmatic identifier indicating the reason for the condition’s last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty. |
| status | string | status of the condition, one of True, False, Unknown. |
| type | string | type of condition in CamelCase or in foo.example.com/CamelCase. |
# remoteowners.md
# RemoteOwner (scylla.scylladb.com/v1alpha1)
**APIVersion**: scylla.scylladb.com/v1alpha1
**Kind**: RemoteOwner
**PluralName**: remoteowners
**SingularName**: remoteowner
**Scope**: Namespaced
**ListKind**: RemoteOwnerList
**Served**: true
**Storage**: true
## Description
## Specification
| Property | Type | Description |
|---------------------------------------------------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| apiVersion | string | 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](https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources) |
| kind | string | 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](https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds) |
| [metadata](#api-scylla-scylladb-com-remoteowners-v1alpha1-metadata) | object | |
### .metadata
#### Description
#### Type
object
# replace-nodes.md
# Replace nodes
Replace a dead or unhealthy ScyllaDB node by labelling its member Service, causing the Operator to provision a fresh node in its place.
## When to replace a node
Replace a node when it is permanently unavailable — the Kubernetes node has been lost, the underlying disk has failed, or the ScyllaDB process is unable to start.
Replacement streams data from other replicas to a new pod, restoring the cluster to full health.
#### NOTE
Replacement is for **permanently failed** nodes.
If a node is temporarily down (for example, during a network partition or host reboot), wait for it to come back.
Replacing a node that is still alive can cause consistency issues.
## How it works
1. You apply the `scylla/replace=""` label to the **member Service** of the failed node.
2. The Operator records the old node’s Host ID, deletes the PVC and evicts the pod.
3. The StatefulSet controller creates a new pod with a fresh PVC.
4. ScyllaDB starts on the new pod with the `--replace-node-first-boot` flag referencing the old Host ID.
5. The new node joins the cluster, takes ownership of the old node’s token range, and streams data from other replicas.
6. Once the new node is Ready, the Operator removes the replace labels from the Service.
## Automatic orphaned node replacement
When a Kubernetes node is permanently removed (for example, a node pool scale-down or a cloud instance termination), the PersistentVolume bound to the ScyllaDB pod becomes orphaned — it references a node that no longer exists.
The Operator’s orphaned PV controller detects this condition and automatically applies the `scylla/replace=""` label on the affected Service, triggering replacement without manual intervention.
To disable this behaviour, set `automaticOrphanedNodeCleanup: false` in the ScyllaCluster spec.
## Replace a dead node in a ScyllaCluster
### Step 1: Identify the failed node
Run `nodetool status` from a healthy node and look for status `DN` (Down and Normal):
```bash
kubectl -n scylla exec scylladb-us-east-1a-0 -c scylla -- nodetool status
```
```default
Datacenter: us-east-1
===========================
Status=Up/Down
|/ State=Normal/Leaving/Joining/Moving
-- Address Load Tokens Owns Host ID Rack
UN 10.43.125.110 74.63 KB 256 ? 8ebd6114-969c-44af-a978-87a4a6c65c3e us-east-1a
UN 10.43.231.189 91.03 KB 256 ? 35d0cb19-35ef-482b-92a4-b63eee4527e5 us-east-1a
DN 10.43.43.51 74.77 KB 256 ? 1ffa7a82-c41c-4706-8f5f-4d45a39c7003 us-east-1a
```
### Step 2: Find the corresponding Service
Match the IP address of the `DN` node to its member Service:
```bash
kubectl -n scylla get svc -l scylla/cluster=scylladb -o wide
```
Identify the Service with the matching ClusterIP (in this example, `10.43.43.51` corresponds to `scylladb-us-east-1a-2`).
### Step 3: Drain the Kubernetes node (if still accessible)
If the failed Kubernetes node is still present in the cluster, drain it to release any remaining resources.
`kubectl drain` performs two actions: it **cordons** the node (marks it `SchedulingDisabled` so no new pods can be scheduled on it) and **evicts** all evictable pods gracefully, giving them time to shut down cleanly.
```bash
kubectl drain --ignore-daemonsets --delete-emptydir-data
```
**Flag reference:**
- `--ignore-daemonsets` — required because ScyllaDB’s node-tuning DaemonSet pods run on every node. Without this flag, `kubectl drain` refuses to proceed. DaemonSet pods are ignored and remain on the node; they are rescheduled automatically when a replacement node comes up.
- `--delete-emptydir-data` — required only if any pod on the node uses `emptyDir` volumes. Include it to acknowledge that the emptyDir data will be lost when the pod is evicted.
**What to expect:** non-DaemonSet pods are evicted one by one. The node transitions to `SchedulingDisabled` status. The ScyllaDB pod should enter `Pending` state after the drain.
#### NOTE
If the Kubernetes node has already been removed (for example, a terminated cloud instance), skip this step.
### Step 4: Trigger the replacement
Apply the replace label to the member Service:
```bash
kubectl -n scylla label svc scylladb-us-east-1a-2 scylla/replace=""
```
The Operator deletes the PVC and pod, then the StatefulSet recreates the pod on an available node.
The new node starts with the replace flag and begins streaming data from other replicas.
### Step 5: Wait for the replacement to complete
Monitor the pod status:
```bash
kubectl -n scylla get pods -w
```
The new pod initially shows fewer ready containers while ScyllaDB bootstraps and streams data.
Once streaming completes, the pod becomes fully Ready.
Wait for the cluster conditions:
```bash
kubectl -n scylla wait --timeout=30m --for='condition=Progressing=False' scyllacluster.scylla.scylladb.com/scylladb
kubectl -n scylla wait --timeout=30m --for='condition=Available=True' scyllacluster.scylla.scylladb.com/scylladb
```
### Step 6: Verify and repair
Confirm all nodes report `UN`:
```bash
kubectl -n scylla exec scylladb-us-east-1a-0 -c scylla -- nodetool status
```
Run a repair to ensure data consistency:
```bash
kubectl -n scylla exec scylladb-us-east-1a-0 -c scylla -- nodetool repair
```
Or use ScyllaDB Manager scheduled repair tasks for automated repair.
#### NOTE
In multi-DC clusters using multiple `ScyllaCluster` resources, node replacement is performed on the individual `ScyllaCluster` resource in the Kubernetes cluster hosting the failed node.
## When replacement fails
If the replacement gets stuck — for example, the new pod enters `CrashLoopBackOff` or streaming cannot complete — see [Recovering from a failed replace](https://operator.docs.scylladb.com/stable/troubleshoot/recover-from-failed-replace.md) for a step-by-step fallback procedure.
## Related pages
- [Scaling](https://operator.docs.scylladb.com/stable/operate/scale-add-remove-racks.md) — adding or removing nodes without replacement
- [StatefulSets and racks](https://operator.docs.scylladb.com/stable/understand/statefulsets-and-racks.md) — pod identity and ordinal management
- [Recovering from a failed replace](https://operator.docs.scylladb.com/stable/troubleshoot/recover-from-failed-replace.md) — fallback when replacement is stuck
- [Rolling restart](https://operator.docs.scylladb.com/stable/operate/perform-rolling-restart.md) — restarting nodes without replacement
# restore-from-backup.md
# Restore from backup
Restore from backup taken using [ScyllaDB Manager](https://operator.docs.scylladb.com/stable/understand/manager.md) to a fresh **empty** cluster of any size.
## Prerequisites
- A running ScyllaDB cluster managed by ScyllaDB Operator.
- ScyllaDB Manager installed and the cluster registered with Manager.
- A backup snapshot stored in object storage (Amazon S3, Google Cloud Storage, or Azure Blob Storage).
- The target cluster has access to the backup bucket (same object storage credentials as the source).
In the following example, the ScyllaCluster, which was used to take the backup, is called `source`. Backup will be restored into the ScyllaCluster named `target`.
Source ScyllaCluster
```yaml
apiVersion: scylla.scylladb.com/v1
kind: ScyllaCluster
metadata:
name: source
spec:
version: 6.2.2
developerMode: true
backups:
- name: foo
location:
- s3:source-backup
keyspace:
- '*'
datacenter:
name: us-east-1
racks:
- name: us-east-1a
members: 1
storage:
capacity: 1Gi
resources:
limits:
cpu: 1
memory: 1Gi
```
Target ScyllaCluster
```yaml
apiVersion: scylla.scylladb.com/v1
kind: ScyllaCluster
metadata:
name: target
spec:
version: 6.2.2
developerMode: true
datacenter:
name: us-east-1
racks:
- name: us-east-1a
members: 1
storage:
capacity: 1Gi
resources:
limits:
cpu: 1
memory: 1Gi
```
Make sure your target cluster is already registered in ScyllaDB Manager. To get a list of all registered clusters, execute the following command:
```console
$ kubectl -n scylla-manager exec -ti deployment.apps/scylla-manager -- sctool cluster list
+--------------------------------------+---------------------------------------+---------+-----------------+
| ID | Name | Port | CQL credentials |
+--------------------------------------+---------------------------------------+---------+-----------------+
| af1dd5cd-0406-4974-949f-dc9842980080 | scylla/target | default | set |
| ebd82268-efb7-407e-a540-3619ae053778 | scylla/source | default | set |
+--------------------------------------+---------------------------------------+---------+-----------------+
```
Identify the tag of a snapshot which you want to restore. To get a list of all available snapshots, execute following command:
```console
kubectl -n scylla-manager exec -ti deployment.apps/scylla-manager -- sctool backup list -c --all-clusters -L
```
Where:
* `CLUSTER_ID` - the name or ID of a registered cluster with access to `BACKUP_LOCATION`.
* `BACKUP_LOCATION` - the location in which the backup is stored.
In this example, `BACKUP_LOCATION` is `s3:source-backup`. Use the name of cluster which has access to the backup location for `CLUSTER_ID`.
In this example, it’s `scylla/target`.
```console
$ kubectl -n scylla-manager exec -ti deployment.apps/scylla-manager -- sctool backup list -c scylla/target --all-clusters -L s3:source-backup
backup/ff36d7e0-af2e-458c-afe6-868e0f3396b2
Snapshots:
- sm_20240105115931UTC (409MiB, 1 nodes)
Keyspaces:
- system_schema (15 tables)
- users (9 tables)
```
## Restore schema
In the below commands, we are restoring the `sm_20240105115931UTC` snapshot. Replace it with a tag of a snapshot that you want to restore.
Restoring consist of two steps. First, you’ll restore the schema, and then the data.
To restore schema, create a restore task manually on target ScyllaCluster by executing following command:
```console
kubectl -n scylla-manager exec -ti deployment.apps/scylla-manager -- sctool restore -c -L -T --restore-schema
```
Where:
* `CLUSTER_ID` - a name or ID of a cluster you want to restore into.
* `BACKUP_LOCATION` - the location in which the backup is stored.
* `SNAPSHOT_TAG` - a tag of a snapshot that you want to restore.
When the task is created, the command will output the ID of a restore task.
```console
$ kubectl -n scylla-manager exec -ti deployment.apps/scylla-manager -- sctool restore -c scylla/target -L s3:source-backup -T sm_20240105115931UTC --restore-schema
restore/57228c52-7cf6-4271-8c8d-d446ff160747
```
Use the following command to check progress of the restore task:
```console
$ kubectl -n scylla-manager exec -ti deployment.apps/scylla-manager -- sctool progress -c scylla/target restore/57228c52-7cf6-4271-8c8d-d446ff160747
Restore progress
Run: 0dd20cdf-abc4-11ee-951c-6e7993cf42ed
Status: DONE
Start time: 05 Jan 24 12:15:02 UTC
End time: 05 Jan 24 12:15:09 UTC
Duration: 6s
Progress: 100% | 100%
Snapshot Tag: sm_20240105115931UTC
+---------------+-------------+----------+----------+------------+--------+
| Keyspace | Progress | Size | Success | Downloaded | Failed |
+---------------+-------------+----------+----------+------------+--------+
| system_schema | 100% | 100% | 214.150k | 214.150k | 214.150k | 0 |
+---------------+-------------+----------+----------+------------+--------+
```
For more details, refer to the [ScyllaDB Manager Restore Schema Documentation](https://manager.docs.scylladb.com/stable/restore/restore-schema.html).
## Restore tables
To restore the tables content, create a restore task manually on target ScyllaCluster by executing the following command:
```console
kubectl -n scylla-manager exec -ti deployment.apps/scylla-manager -- sctool restore -c -L -T --restore-tables
```
Where:
* `CLUSTER_ID` - a name or ID of a cluster you want to restore into.
* `BACKUP_LOCATION` - the location in which the backup is stored.
* `SNAPSHOT_TAG` - a tag of a snapshot that you want to restore.
When the task is created, the command will output the ID of a restore task.
```console
$ kubectl -n scylla-manager exec -ti deployment.apps/scylla-manager -- sctool restore -c scylla/target -L s3:source-backup -T sm_20240105115931UTC --restore-tables
restore/63642069-bed5-4def-ba0f-68c49e47ace1
```
Use the following command to check progress of the restore task:
```console
$ kubectl -n scylla-manager exec -ti deployment.apps/scylla-manager -- sctool progress -c scylla/target restore/63642069-bed5-4def-ba0f-68c49e47ace1
Restore progress
Run: ab015cef-abc8-11ee-9521-6e7993cf42ed
Status: DONE
Start time: 05 Jan 24 12:48:04 UTC
End time: 05 Jan 24 12:48:15 UTC
Duration: 11s
Progress: 100% | 100%
Snapshot Tag: sm_20240105115931UTC
+-------------+-------------+--------+---------+------------+--------+
| Keyspace | Progress | Size | Success | Downloaded | Failed |
+-------------+-------------+--------+---------+------------+--------+
| users | 100% | 100% | 409MiB | 409MiB | 409MiB | 0 |
+-------------+-------------+--------+---------+------------+--------+
Post-restore repair progress
Run: ab015cef-abc8-11ee-9521-6e7993cf42ed
Status: DONE
Start time: 05 Jan 24 12:48:04 UTC
End time: 05 Jan 24 12:48:15 UTC
Duration: 11s
Progress: 100%
Intensity: 1
Parallel: 0
Datacenters:
- us-east-1
+-------------+--------------+----------+----------+
| Keyspace | Table | Progress | Duration |
+-------------+--------------+----------+----------+
| users | users | 100% | 0s |
+-------------+--------------+----------+----------+
```
## Verify the restore
Connect to the target cluster and verify your data is present:
```bash
kubectl -n scylla exec -it target-us-east-1-us-east-1a-0 -c scylla -- cqlsh
```
```sql
DESCRIBE KEYSPACES;
SELECT COUNT(*) FROM users.users;
```
## Related pages
- [Back up and restore](https://operator.docs.scylladb.com/stable/operate/back-up-and-restore.md) — overview of backup and restore with ScyllaDB Manager.
- [ScyllaDB Manager](https://operator.docs.scylladb.com/stable/understand/manager.md) — how Manager integrates with the Operator.
- [ScyllaDB Manager Restore Documentation](https://manager.docs.scylladb.com/stable/restore/) — upstream Manager restore reference.
# rf-warning.md
#### WARNING
To ensure high availability and fault tolerance in ScyllaDB, it is crucial to **spread your nodes across multiple racks or availability zones**. As a general rule of thumb, you should use **as many racks as your desired replication factor**.
For example, if your replication factor is `3`, deploy your nodes across **3 different racks or availability zones**. This minimizes the risk of data loss and ensures your cluster remains available even if an entire rack or zone fails.
# scale-add-remove-racks.md
# Scale, add, remove racks
Change the number of ScyllaDB nodes in a rack or add entirely new racks to adjust capacity and throughput.
## How scaling works
Each rack in a ScyllaDB cluster maps to a single Kubernetes StatefulSet.
Scaling changes the replica count of that StatefulSet:
- **Scale up** — new pods are appended at the end of the ordinal sequence (highest index).
After the new node joins the token ring, the Operator automatically triggers a [data cleanup](https://operator.docs.scylladb.com/stable/understand/automatic-data-cleanup.md) on affected nodes.
- **Scale down** — the Operator decommissions the highest-ordinal pod first, streams its data to the remaining nodes, reduces the replica count, and then deletes the PVC and Service.
Only one node is decommissioned at a time.
Because StatefulSets maintain contiguous pod ordinals and scale down from the highest ordinal, you cannot remove an arbitrary node from the middle of a rack.
If a specific node is unhealthy, use [node replacement](https://operator.docs.scylladb.com/stable/operate/replace-nodes.md) instead.
For background on the StatefulSet-per-rack architecture, see [StatefulSets and racks](https://operator.docs.scylladb.com/stable/understand/statefulsets-and-racks.md).
## Sequential and parallel node provisioning
The Operator controls how it provisions new nodes with parallel node operations. They determine whether Operator starts ScyllaDB nodes one at a time or all at once: when you create a cluster, add, or scale-out a rack.
With parallel node operations disabled, Operator starts ScyllaDB nodes one at a time. Within a rack, each Pod must become ready before Operator starts the next one. Operator creates racks one at a time. Bringing up a cluster takes as long as the sum of every node’s startup time.
With parallel node operations enabled, Operator starts all ScyllaDB nodes at once. Operator starts Pods of a rack without waiting for the previous ones to become ready. Operator creates all racks at the same time. Bringing up a cluster is faster, and the difference grows with the number of nodes.
Parallel node operations provide better performance when your keyspaces are backed by tablets (the default since ScyllaDB 2025.2), as opposed to vnodes. Therefore, we strongly recommend that you only use tablets for your data keyspaces. This is because with vnode-based keyspaces, a joining node streams its data before it finishes joining, which slows down bringing up new nodes. With tablets, the data is moved in the background after the node joins, so the time to bring up new nodes is not affected by data streaming.
Consider setting [`tablets_mode_for_new_keyspaces`](https://docs.scylladb.com/manual/stable/architecture/tablets.html#enabling-tablets) to `enforced` in your [ScyllaDB configuration](https://operator.docs.scylladb.com/stable/deploy-scylladb/deploy-your-first-cluster.md#create-a-scylladb-configuration) to prevent individual keyspaces from opting out of tablets.
#### NOTE
The Operator waits for the cluster to settle before creating new racks. An in-flight scaling operation, configuration update, or version upgrade delays the creation of new nodes either way.
### Configure parallel node operations
You can configure parallel node operations with the `spec.enableParallelNodeOperations` field of a `ScyllaCluster`, which accepts `true` and `false`.
```yaml
apiVersion: scylla.scylladb.com/v1
kind: ScyllaCluster
metadata:
name: scylla
namespace: scylla
spec:
enableParallelNodeOperations: true
```
#### WARNING
The field currently only controls how nodes are started. Its scope is expected to widen in a future release, where it will also allow decommissioning nodes in parallel.
Setting it to `true` now takes effect for those operations after you upgrade the Operator, without another change to the spec.
If you don’t specify the field, the Operator defaults it to `true` on creation, provided the ScyllaDB version is higher or equal to 2026.2.
Operator keeps bootstrapping the nodes of clusters that already existed before the addition of this feature sequentially.
It is recommended that you set the field to `true` explicitly to bootstrap new nodes in parallel.
## Bootstrap synchronisation
In Kubernetes, Pods can start simultaneously, and a new node could attempt to bootstrap while another node is still restarting and appears down to its peers. ScyllaDB denies such a join request and leaves the new node in a state that is not recoverable automatically.
Enabling the `BootstrapSynchronisation` feature gate protects against this by holding each node’s startup until all nodes in the cluster are UP.
It is recommended that you enable it whether or not parallel node operations are enabled. See [Bootstrap synchronisation](https://operator.docs.scylladb.com/stable/understand/bootstrap-sync.md) for details on the mechanism and [Feature gates](https://operator.docs.scylladb.com/stable/reference/feature-gates.md) for instructions on enabling feature gates.
## Scale a ScyllaCluster
Change `spec.datacenter.racks[].members` to the desired node count and apply:
Scale up
```yaml
apiVersion: scylla.scylladb.com/v1
kind: ScyllaCluster
metadata:
name: scylla
namespace: scylla
spec:
datacenter:
name: us-east-1
racks:
- name: us-east-1a
members: 3 # was 1, now 3
storage:
capacity: 500Gi
```
Scale down
```yaml
apiVersion: scylla.scylladb.com/v1
kind: ScyllaCluster
metadata:
name: scylla
namespace: scylla
spec:
datacenter:
name: us-east-1
racks:
- name: us-east-1a
members: 1 # was 3, now 1
storage:
capacity: 500Gi
```
Wait for the operation to complete:
```bash
kubectl -n scylla wait --timeout=10m --for='condition=Available' scyllaclusters.scylla.scylladb.com/scylla
```
Verify with `nodetool status`:
```bash
kubectl -n scylla exec -it scylla-us-east-1a-0 -c scylla -- nodetool status
```
## Add a rack to a ScyllaCluster
Append a new entry to the `spec.datacenter.racks` array.
The Operator creates racks in the order they appear and waits for each rack to be fully ready before creating the next.
```yaml
apiVersion: scylla.scylladb.com/v1
kind: ScyllaCluster
metadata:
name: scylla
namespace: scylla
spec:
datacenter:
name: us-east-1
racks:
- name: us-east-1a
members: 3
storage:
capacity: 500Gi
- name: us-east-1b # new rack
members: 3
storage:
capacity: 500Gi
```
#### NOTE
Rack names serve as identity — they determine the StatefulSet and Service names.
Choose rack names carefully, as renaming a rack requires removing it and creating a new one.
### Remove a rack
Removing a rack is a two-step process.
You must scale the rack to zero members first, wait for decommissioning to finish, and only then remove the rack definition from the spec.
#### Step 1: Scale the rack down to 0 members
Update the ScyllaCluster spec to set `members: 0` for the rack being removed:
```bash
kubectl -n scylla patch scyllacluster scylla --type=json \
-p='[{"op":"replace","path":"/spec/datacenter/racks//members","value":0}]'
```
Replace `` with the zero-based index of the rack in the `racks` array.
Wait for the Operator to decommission all nodes in the rack:
```bash
kubectl -n scylla wait --timeout=30m \
--for='condition=Available=True' scyllacluster/scylla
```
Verify all pods in the rack are gone:
```bash
kubectl -n scylla get pods -l scylla/rack=
```
Expected output: no pods listed.
#### Step 2: Remove the rack definition from the spec
Remove the rack entry from `spec.datacenter.racks`:
```bash
kubectl -n scylla edit scyllacluster scylla
```
Delete the entire rack entry. Save and apply.
#### WARNING
Removing a rack is irreversible — any data that was stored on the rack’s nodes is streamed away during decommission.
After both steps, verify the cluster is healthy:
```bash
kubectl -n scylla wait --timeout=5m \
--for='condition=Available=True' scyllacluster/scylla
```
#### NOTE
In multi-DC clusters using multiple `ScyllaCluster` resources, each datacenter is scaled independently by editing its own `ScyllaCluster` resource.
## Key considerations
| Consideration | Detail |
|--------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------|
| One at a time | The Operator scales down one node at a time per rack, ensuring data is streamed away before the next decommission begins. |
| Automatic cleanup | After scaling completes, the Operator triggers data cleanup Jobs on affected nodes to remove data that no longer belongs to them. |
| PVC deletion | PVCs are deleted after scale-down. The Operator removes the PVC and Service of each decommissioned node after the replica count is reduced. |
| Replication factor | Ensure you do not scale below the replication factor of your keyspaces. ScyllaDB will refuse queries if replicas become unavailable. |
| PodDisruptionBudget | Each datacenter has a PDB with `maxUnavailable: 1`. This does not block Operator-driven scaling but prevents concurrent pod evictions during node drains. |
| Run repair after scaling | After significant scaling operations, run a repair to ensure data consistency across the new token ranges. |
## Related pages
- [StatefulSets and racks](https://operator.docs.scylladb.com/stable/understand/statefulsets-and-racks.md) — how StatefulSets map to racks and why mid-set removal is not possible
- [Bootstrap synchronisation](https://operator.docs.scylladb.com/stable/understand/bootstrap-sync.md) — the mechanism gating bootstrap on the cluster’s node statuses
- [Replace nodes](https://operator.docs.scylladb.com/stable/operate/replace-nodes.md) — replacing a specific unhealthy node without scaling
- [Migrate a rack to a new node pool](https://operator.docs.scylladb.com/stable/operate/migrate-rack-to-new-node-pool.md) — scaling up a new rack and scaling down the old one to migrate infrastructure
- [Perform a rolling restart](https://operator.docs.scylladb.com/stable/operate/perform-rolling-restart.md) — restarting all nodes without changing the cluster size
- [Data distribution with tablets](https://docs.scylladb.com/manual/stable/architecture/tablets.html) — how tablets distribute data and why they speed up topology changes
# scylla.scylladb.com.md
# scylla.scylladb.com
* [NodeConfig (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/nodeconfigs.md)
* [RemoteKubernetesCluster (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/remotekubernetesclusters.md)
* [RemoteOwner (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/remoteowners.md)
* [ScyllaCluster (scylla.scylladb.com/v1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/scyllaclusters.md)
* [ScyllaDBCluster (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/scylladbclusters.md)
* [ScyllaDBDatacenterNodesStatusReport (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/scylladbdatacenternodesstatusreports.md)
* [ScyllaDBDatacenter (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/scylladbdatacenters.md)
* [ScyllaDBManagerClusterRegistration (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/scylladbmanagerclusterregistrations.md)
* [ScyllaDBManagerTask (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/scylladbmanagertasks.md)
* [ScyllaDBMonitoring (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/scylladbmonitorings.md)
* [ScyllaOperatorConfig (scylla.scylladb.com/v1alpha1)](https://operator.docs.scylladb.com/stable/reference/api/groups/scylla.scylladb.com/scyllaoperatorconfigs.md)
# scyllaclusters.md
# ScyllaCluster (scylla.scylladb.com/v1)
**APIVersion**: scylla.scylladb.com/v1
**Kind**: ScyllaCluster
**PluralName**: scyllaclusters
**SingularName**: scyllacluster
**Scope**: Namespaced
**ListKind**: ScyllaClusterList
**Served**: true
**Storage**: true
## Description
ScyllaCluster defines a Scylla cluster.
## Specification
| Property | Type | Description |
|-----------------------------------------------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| apiVersion | string | 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](https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources) |
| kind | string | 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](https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds) |
| [metadata](#api-scylla-scylladb-com-scyllaclusters-v1-metadata) | object | |
| [spec](#api-scylla-scylladb-com-scyllaclusters-v1-spec) | object | spec defines the desired state of this scylla cluster. |
| [status](#api-scylla-scylladb-com-scyllaclusters-v1-status) | object | status is the current status of this scylla cluster. |
### .metadata
#### Description
#### Type
object
### .spec
#### Description
spec defines the desired state of this scylla cluster.
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| agentRepository | string | agentRepository is the repository to pull the agent image from. |
| agentVersion | string | agentVersion indicates the version of Scylla Manager Agent to use. |
| [alternator](#api-scylla-scylladb-com-scyllaclusters-v1-spec-alternator) | object | alternator designates this cluster an Alternator cluster. |
| automaticOrphanedNodeCleanup | boolean | automaticOrphanedNodeCleanup controls if automatic orphan node cleanup should be performed. |
| [backups](#api-scylla-scylladb-com-scyllaclusters-v1-spec-backups) | array (object) | backups specifies backup tasks in Scylla Manager. When Scylla Manager is not installed, these will be ignored. |
| cpuset | boolean | cpuset determines if the cluster will use cpu-pinning. Deprecated: cpuset is deprecated. It is now treated as if it is always set to true regardless of its value. |
| [datacenter](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter) | object | datacenter holds a specification of a datacenter. |
| developerMode | boolean | developerMode determines if the cluster runs in developer-mode. |
| dnsDomains | array (string) | dnsDomains is a list of DNS domains this cluster is reachable by. These domains are used when setting up the infrastructure, like certificates. EXPERIMENTAL. Do not rely on any particular behaviour controlled by this field. |
| enableParallelNodeOperations | boolean | enableParallelNodeOperations controls whether operations on ScyllaDB nodes may be performed concurrently. When it’s disabled, ScyllaDB nodes are started one at a time. Enabling it requires ScyllaDB 2026.2 or later. If not provided, it’s treated as disabled. On creation, it’s set to true when spec.version is a semver-parseable version supporting parallel bootstrap. The set value is persisted, so it stays in effect across ScyllaDB version changes until it’s explicitly changed. It’s otherwise left unset, and never set on an already existing object. |
| [exposeOptions](#api-scylla-scylladb-com-scyllaclusters-v1-spec-exposeoptions) | object | exposeOptions specifies options for exposing ScyllaCluster services. This field is immutable. EXPERIMENTAL. Do not rely on any particular behaviour controlled by this field. |
| externalSeeds | array (string) | externalSeeds specifies the external seeds to propagate to ScyllaDB binary on startup as “seeds” parameter of seed-provider. |
| forceRedeploymentReason | string | forceRedeploymentReason can be used to force a rolling update of all racks by providing a unique string. |
| [genericUpgrade](#api-scylla-scylladb-com-scyllaclusters-v1-spec-genericupgrade) | object | genericUpgrade allows to configure behavior of generic upgrade logic. |
| [imagePullSecrets](#api-scylla-scylladb-com-scyllaclusters-v1-spec-imagepullsecrets) | array (object) | imagePullSecrets is an optional list of references to secrets in the same namespace used for pulling Scylla and Agent images. |
| minReadySeconds | integer | minReadySeconds is the minimum number of seconds for which a newly created ScyllaDB node should be ready for it to be considered available. When used to control load balanced traffic, this can give the load balancer in front of a node enough time to notice that the node is ready and start forwarding traffic in time. Because it all depends on timing, the order is not guaranteed and, if possible, you should use readinessGates instead. If not provided, Operator will determine this value. |
| minTerminationGracePeriodSeconds | integer | minTerminationGracePeriodSeconds specifies minimum duration in seconds to wait before every drained node is terminated. This gives time to potential load balancer in front of a node to notice that node is not ready anymore and stop forwarding new requests. This applies only when node is terminated gracefully. If not provided, Operator will determine this value. EXPERIMENTAL. Do not rely on any particular behaviour controlled by this field. |
| [network](#api-scylla-scylladb-com-scyllaclusters-v1-spec-network) | object | network holds the networking config. |
| [podMetadata](#api-scylla-scylladb-com-scyllaclusters-v1-spec-podmetadata) | object | podMetadata controls shared metadata for all pods created based on this spec. |
| [readinessGates](#api-scylla-scylladb-com-scyllaclusters-v1-spec-readinessgates) | array (object) | readinessGates specifies custom readiness gates that will be evaluated for every ScyllaDB Pod readiness. It’s projected into every ScyllaDB Pod as its readinessGate. Refer to upstream documentation to learn more about readiness gates. |
| [repairs](#api-scylla-scylladb-com-scyllaclusters-v1-spec-repairs) | array (object) | repairs specify repair tasks in Scylla Manager. When Scylla Manager is not installed, these will be ignored. |
| repository | string | repository is the image repository to pull the Scylla image from. |
| scyllaArgs | string | scyllaArgs will be appended to Scylla binary during startup. This is supported from 4.2.0 Scylla version. |
| sysctls | array (string) | sysctls holds the sysctl properties to be applied during initialization given as a list of key=value pairs. Example: fs.aio-max-nr=232323 Deprecated: sysctls is deprecated. Use NodeConfig to configure sysctls instead. See NodeConfig resource reference for details. |
| version | string | version is a version tag of Scylla to use. |
### .spec.alternator
#### Description
alternator designates this cluster an Alternator cluster.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| insecureDisableAuthorization | boolean | insecureDisableAuthorization disables Alternator authorization. If not specified, the authorization is enabled. For backwards compatibility the authorization is disabled when this field is not specified and a manual port is used. |
| insecureEnableHTTP | boolean | insecureEnableHTTP enables serving Alternator traffic also on insecure HTTP port. |
| port | integer | port is the port number used to bind the Alternator API. Deprecated: port is deprecated and may be ignored in the future. Please make sure to avoid using hostNetworking and work with standard Kubernetes concepts like Services. |
| [servingCertificate](#api-scylla-scylladb-com-scyllaclusters-v1-spec-alternator-servingcertificate) | object | servingCertificate references a TLS certificate for serving secure traffic. |
| writeIsolation | string | writeIsolation indicates the isolation level. |
### .spec.alternator.servingCertificate
#### Description
servingCertificate references a TLS certificate for serving secure traffic.
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------------------------------|--------|-----------------------------------------------------------------------------------|
| [operatorManagedOptions](#api-scylla-scylladb-com-scyllaclusters-v1-spec-alternator-servingcertificate-operatormanagedoptions) | object | operatorManagedOptions specifies options for certificates manged by the operator. |
| type | string | type determines the source of this certificate. |
| [userManagedOptions](#api-scylla-scylladb-com-scyllaclusters-v1-spec-alternator-servingcertificate-usermanagedoptions) | object | userManagedOptions specifies options for certificates manged by users. |
### .spec.alternator.servingCertificate.operatorManagedOptions
#### Description
operatorManagedOptions specifies options for certificates manged by the operator.
#### Type
object
| Property | Type | Description |
|-----------------------|----------------|----------------------------------------------------------------------------------------------------|
| additionalDNSNames | array (string) | additionalDNSNames represents external DNS names that the certificates should be signed for. |
| additionalIPAddresses | array (string) | additionalIPAddresses represents external IP addresses that the certificates should be signed for. |
### .spec.alternator.servingCertificate.userManagedOptions
#### Description
userManagedOptions specifies options for certificates manged by users.
#### Type
object
| Property | Type | Description |
|------------|--------|----------------------------------------------------------------------------------------|
| secretName | string | secretName references a kubernetes.io/tls type secret containing the TLS cert and key. |
### .spec.backups[]
#### Description
#### Type
object
| Property | Type | Description |
|------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| cron | string | cron specifies the task schedule as a cron expression. It supports an extended syntax including @monthly, @weekly, @daily, @midnight, @hourly, @every X[h|m|s]. |
| dc | array (string) | dc is a list of datacenter glob patterns, e.g. ‘dc1,!otherdc\*’ used to specify the DCs to include or exclude from backup. |
| interval | string | interval represents a task schedule interval e.g. 3d2h10m, valid units are d, h, m, s. Deprecated: please use cron instead. |
| keyspace | array (string) | keyspace is a list of keyspace/tables glob patterns, e.g. ‘keyspace,!keyspace.table_prefix_\*’ used to include or exclude keyspaces from repair. |
| location | array (string) | location is a list of backup locations in the format [:]: ex. s3:my-bucket. The : part is optional and is only needed when different datacenters are being used to upload data to different locations. must be an alphanumeric string and may contain a dash and or a dot, but other characters are forbidden. The only supported storage at the moment are s3 and gcs. |
| name | string | name specifies the name of a task. |
| numRetries | integer | numRetries indicates how many times a scheduled task will be retried before failing. |
| rateLimit | array (string) | rateLimit is a list of megabytes (MiB) per second rate limits expressed in the format [:]. The : part is optional and only needed when different datacenters need different upload limits. Set to 0 for no limit (default 100). |
| retention | integer | retention is the number of backups which are to be stored. |
| retryWait | string | retryWait specifies the initial exponential backoff duration for task retries. For instance, if set to 10 minutes, the first retry will be attempted after 10 minutes, the second after 20 minutes, the third after 40 minutes, and so on, up to the number of retries specified in numRetries. If not set, the default values is left to ScyllaDB Manager to decide. |
| snapshotParallel | array (string) | snapshotParallel is a list of snapshot parallelism limits in the format [:]. The : part is optional and allows for specifying different limits in selected datacenters. If The : part is not set, the limit is global (e.g. ‘dc1:2,5’) the runs are parallel in n nodes (2 in dc1) and n nodes in all the other datacenters. |
| startDate | string | startDate specifies the task start date expressed in the RFC3339 format or now[+duration], e.g. now+3d2h10m, valid units are d, h, m, s. |
| timezone | string | timezone specifies the timezone of cron field. |
| uploadParallel | array (string) | uploadParallel is a list of upload parallelism limits in the format [:]. The : part is optional and allows for specifying different limits in selected datacenters. If The : part is not set the limit is global (e.g. ‘dc1:2,5’) the runs are parallel in n nodes (2 in dc1) and n nodes in all the other datacenters. |
### .spec.datacenter
#### Description
datacenter holds a specification of a datacenter.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------|----------------|------------------------------------------------------------------------------------------|
| name | string | name is the name of the scylla datacenter. Used in the cassandra-rackdc.properties file. |
| [racks](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks) | array (object) | racks specify the racks in the datacenter. |
### .spec.datacenter.racks[]
#### Description
RackSpec is the desired state for a Scylla Rack.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------|----------------|----------------------------------------------------------------------------------------------------------|
| [agentResources](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-agentresources) | object | agentResources specify the resources for the Agent container. |
| [agentVolumeMounts](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-agentvolumemounts) | array (object) | AgentVolumeMounts to be added to Agent container. |
| [exposeOptions](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-exposeoptions) | object | exposeOptions specifies rack-specific parameters related to exposing ScyllaDBDatacenter backends. |
| members | integer | members is the number of Scylla instances in this rack. |
| name | string | name is the name of the Scylla Rack. Used in the cassandra-rackdc.properties file. |
| [placement](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement) | object | placement describes restrictions for the nodes Scylla is scheduled on. |
| [resources](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-resources) | object | resources the Scylla container will use. |
| scyllaAgentConfig | string | ScyllaAgentConfig specifies a reference to custom ScyllaDB Manager Agent configuration stored as Secret. |
| scyllaConfig | string | Scylla config map name to customize scylla.yaml |
| [storage](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-storage) | object | storage describes the underlying storage that Scylla will consume. |
| [volumeMounts](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumemounts) | array (object) | VolumeMounts to be added to Scylla container. |
| [volumes](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes) | array (object) | Volumes added to Scylla Pod. |
### .spec.datacenter.racks[].agentResources
#### Description
agentResources specify the resources for the Agent container.
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------|----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [claims](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-agentresources-claims) | array (object) | Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. This field depends on the DynamicResourceAllocation feature gate. This field is immutable. It can only be set for containers. |
| [limits](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-agentresources-limits) | object | Limits describes the maximum amount of compute resources allowed. More info: [https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) |
| [requests](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-agentresources-requests) | object | 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. Requests cannot exceed Limits. More info: [https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) |
### .spec.datacenter.racks[].agentResources.claims[]
#### Description
ResourceClaim references one entry in PodSpec.ResourceClaims.
#### Type
object
| Property | Type | Description |
|------------|--------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| name | string | Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container. |
| request | string | Request is the name chosen for a request in the referenced claim. If empty, everything from the claim is made available, otherwise only the result of this request. |
### .spec.datacenter.racks[].agentResources.limits
#### Description
Limits describes the maximum amount of compute resources allowed. More info: [https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/)
#### Type
object
### .spec.datacenter.racks[].agentResources.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. Requests cannot exceed Limits. More info: [https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/)
#### Type
object
### .spec.datacenter.racks[].agentVolumeMounts[]
#### Description
VolumeMount describes a mounting of a Volume within a container.
#### Type
object
| Property | Type | Description |
|-------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| mountPath | string | Path within the container at which the volume should be mounted. Must not contain ‘:’. |
| mountPropagation | string | 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. When RecursiveReadOnly is set to IfPossible or to Enabled, MountPropagation must be None or unspecified (which defaults to None). |
| name | string | This must match the Name of a Volume. |
| readOnly | boolean | Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false. |
| recursiveReadOnly | string | RecursiveReadOnly specifies whether read-only mounts should be handled recursively. If ReadOnly is false, this field has no meaning and must be unspecified. If ReadOnly is true, and this field is set to Disabled, the mount is not made recursively read-only. If this field is set to IfPossible, the mount is made recursively read-only, if it is supported by the container runtime. If this field is set to Enabled, the mount is made recursively read-only if it is supported by the container runtime, otherwise the pod will not be started and an error will be generated to indicate the reason. If this field is set to IfPossible or Enabled, MountPropagation must be set to None (or be unspecified, which defaults to None). If this field is not specified, it is treated as an equivalent of Disabled. |
| subPath | string | Path within the volume from which the container’s volume should be mounted. Defaults to “” (volume’s root). |
| subPathExpr | string | 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. |
### .spec.datacenter.racks[].exposeOptions
#### Description
exposeOptions specifies rack-specific parameters related to exposing ScyllaDBDatacenter backends.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------|--------|------------------------------------------------------------------------------------------------------|
| [nodeService](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-exposeoptions-nodeservice) | object | nodeService controls properties of Service dedicated for each ScyllaDBDatacenter node in given rack. |
### .spec.datacenter.racks[].exposeOptions.nodeService
#### Description
nodeService controls properties of Service dedicated for each ScyllaDBDatacenter node in given rack.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------|--------|-----------------------------------------------------------------------------------------|
| [annotations](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-exposeoptions-nodeservice-annotations) | object | annotations is a custom key value map that gets merged with managed object annotations. |
| [labels](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-exposeoptions-nodeservice-labels) | object | labels is a custom key value map that gets merged with managed object labels. |
### .spec.datacenter.racks[].exposeOptions.nodeService.annotations
#### Description
annotations is a custom key value map that gets merged with managed object annotations.
#### Type
object
### .spec.datacenter.racks[].exposeOptions.nodeService.labels
#### Description
labels is a custom key value map that gets merged with managed object labels.
#### Type
object
### .spec.datacenter.racks[].placement
#### Description
placement describes restrictions for the nodes Scylla is scheduled on.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------|
| [nodeAffinity](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-nodeaffinity) | object | nodeAffinity describes node affinity scheduling rules for the pod. |
| [podAffinity](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podaffinity) | object | podAffinity describes pod affinity scheduling rules. |
| [podAntiAffinity](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podantiaffinity) | object | podAntiAffinity describes pod anti-affinity scheduling rules. |
| [tolerations](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-tolerations) | array (object) | tolerations allow the pod to tolerate any taint that matches the triple using the matching operator. |
### .spec.datacenter.racks[].placement.nodeAffinity
#### Description
nodeAffinity describes node affinity scheduling rules for the pod.
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [preferredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-nodeaffinity-preferredduringschedulingignoredduringexecution) | array (object) | 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. |
| [requiredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-nodeaffinity-requiredduringschedulingignoredduringexecution) | object | 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. |
### .spec.datacenter.racks[].placement.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
#### 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).
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|-----------------------------------------------------------------------------------------|
| [preference](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-nodeaffinity-preferredduringschedulingignoredduringexecution-preference) | object | A node selector term, associated with the corresponding weight. |
| weight | integer | Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100. |
### .spec.datacenter.racks[].placement.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference
#### Description
A node selector term, associated with the corresponding weight.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-nodeaffinity-preferredduringschedulingignoredduringexecution-preference-matchexpressions) | array (object) | A list of node selector requirements by node’s labels. |
| [matchFields](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-nodeaffinity-preferredduringschedulingignoredduringexecution-preference-matchfields) | array (object) | A list of node selector requirements by node’s fields. |
### .spec.datacenter.racks[].placement.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchExpressions[]
#### Description
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | The label key that the selector applies to. |
| operator | string | Represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. |
| values | array (string) | 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. |
### .spec.datacenter.racks[].placement.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchFields[]
#### Description
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | The label key that the selector applies to. |
| operator | string | Represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. |
| values | array (string) | 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. |
### .spec.datacenter.racks[].placement.nodeAffinity.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.
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------------|
| [nodeSelectorTerms](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-nodeaffinity-requiredduringschedulingignoredduringexecution-nodeselectorterms) | array (object) | Required. A list of node selector terms. The terms are ORed. |
### .spec.datacenter.racks[].placement.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[]
#### 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.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-nodeaffinity-requiredduringschedulingignoredduringexecution-nodeselectorterms-matchexpressions) | array (object) | A list of node selector requirements by node’s labels. |
| [matchFields](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-nodeaffinity-requiredduringschedulingignoredduringexecution-nodeselectorterms-matchfields) | array (object) | A list of node selector requirements by node’s fields. |
### .spec.datacenter.racks[].placement.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchExpressions[]
#### Description
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | The label key that the selector applies to. |
| operator | string | Represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. |
| values | array (string) | 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. |
### .spec.datacenter.racks[].placement.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchFields[]
#### Description
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | The label key that the selector applies to. |
| operator | string | Represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. |
| values | array (string) | 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. |
### .spec.datacenter.racks[].placement.podAffinity
#### Description
podAffinity describes pod affinity scheduling rules.
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [preferredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podaffinity-preferredduringschedulingignoredduringexecution) | array (object) | 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. |
| [requiredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podaffinity-requiredduringschedulingignoredduringexecution) | array (object) | 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. |
### .spec.datacenter.racks[].placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
#### Description
The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|----------------------------------------------------------------------------------------|
| [podAffinityTerm](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm) | object | Required. A pod affinity term, associated with the corresponding weight. |
| weight | integer | weight associated with matching the corresponding podAffinityTerm, in the range 1-100. |
### .spec.datacenter.racks[].placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
#### Description
Required. A pod affinity term, associated with the corresponding weight.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [labelSelector](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector) | object | A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods. |
| matchLabelKeys | array (string) | MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key in (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn’t set. |
| mismatchLabelKeys | array (string) | MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key notin (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn’t set. |
| [namespaceSelector](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector) | object | 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. |
| namespaces | array (string) | 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”. |
| topologyKey | string | 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. |
### .spec.datacenter.racks[].placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
#### Description
A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector-matchlabels) | object | 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. |
### .spec.datacenter.racks[].placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenter.racks[].placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.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
### .spec.datacenter.racks[].placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.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.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector-matchlabels) | object | 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. |
### .spec.datacenter.racks[].placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenter.racks[].placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.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
### .spec.datacenter.racks[].placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
#### 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
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [labelSelector](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podaffinity-requiredduringschedulingignoredduringexecution-labelselector) | object | A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods. |
| matchLabelKeys | array (string) | MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key in (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn’t set. |
| mismatchLabelKeys | array (string) | MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key notin (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn’t set. |
| [namespaceSelector](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podaffinity-requiredduringschedulingignoredduringexecution-namespaceselector) | object | 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. |
| namespaces | array (string) | 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”. |
| topologyKey | string | 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. |
### .spec.datacenter.racks[].placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
#### Description
A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods.
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podaffinity-requiredduringschedulingignoredduringexecution-labelselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podaffinity-requiredduringschedulingignoredduringexecution-labelselector-matchlabels) | object | 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. |
### .spec.datacenter.racks[].placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenter.racks[].placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.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
### .spec.datacenter.racks[].placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].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.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podaffinity-requiredduringschedulingignoredduringexecution-namespaceselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podaffinity-requiredduringschedulingignoredduringexecution-namespaceselector-matchlabels) | object | 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. |
### .spec.datacenter.racks[].placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenter.racks[].placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.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
### .spec.datacenter.racks[].placement.podAntiAffinity
#### Description
podAntiAffinity describes pod anti-affinity scheduling rules.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [preferredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podantiaffinity-preferredduringschedulingignoredduringexecution) | array (object) | 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 subtracting “weight” from the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. |
| [requiredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podantiaffinity-requiredduringschedulingignoredduringexecution) | array (object) | 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. |
### .spec.datacenter.racks[].placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
#### Description
The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|----------------------------------------------------------------------------------------|
| [podAffinityTerm](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm) | object | Required. A pod affinity term, associated with the corresponding weight. |
| weight | integer | weight associated with matching the corresponding podAffinityTerm, in the range 1-100. |
### .spec.datacenter.racks[].placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
#### Description
Required. A pod affinity term, associated with the corresponding weight.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [labelSelector](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector) | object | A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods. |
| matchLabelKeys | array (string) | MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key in (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn’t set. |
| mismatchLabelKeys | array (string) | MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key notin (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn’t set. |
| [namespaceSelector](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector) | object | 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. |
| namespaces | array (string) | 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”. |
| topologyKey | string | 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. |
### .spec.datacenter.racks[].placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
#### Description
A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector-matchlabels) | object | 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. |
### .spec.datacenter.racks[].placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenter.racks[].placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.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
### .spec.datacenter.racks[].placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.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.
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector-matchlabels) | object | 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. |
### .spec.datacenter.racks[].placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenter.racks[].placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.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
### .spec.datacenter.racks[].placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
#### 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
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [labelSelector](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podantiaffinity-requiredduringschedulingignoredduringexecution-labelselector) | object | A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods. |
| matchLabelKeys | array (string) | MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key in (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn’t set. |
| mismatchLabelKeys | array (string) | MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key notin (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn’t set. |
| [namespaceSelector](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podantiaffinity-requiredduringschedulingignoredduringexecution-namespaceselector) | object | 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. |
| namespaces | array (string) | 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”. |
| topologyKey | string | 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. |
### .spec.datacenter.racks[].placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
#### Description
A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podantiaffinity-requiredduringschedulingignoredduringexecution-labelselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podantiaffinity-requiredduringschedulingignoredduringexecution-labelselector-matchlabels) | object | 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. |
### .spec.datacenter.racks[].placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenter.racks[].placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.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
### .spec.datacenter.racks[].placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].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.
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podantiaffinity-requiredduringschedulingignoredduringexecution-namespaceselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-placement-podantiaffinity-requiredduringschedulingignoredduringexecution-namespaceselector-matchlabels) | object | 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. |
### .spec.datacenter.racks[].placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenter.racks[].placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.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
### .spec.datacenter.racks[].placement.tolerations[]
#### Description
The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .
#### Type
object
| Property | Type | Description |
|-------------------|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| effect | string | Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute. |
| key | string | 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. |
| operator | string | Operator represents a key’s relationship to the value. Valid operators are Exists, Equal, Lt, and Gt. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. Lt and Gt perform numeric comparisons (requires feature gate TaintTolerationComparisonOperators). |
| tolerationSeconds | integer | 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. |
| value | string | Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string. |
### .spec.datacenter.racks[].resources
#### Description
resources the Scylla container will use.
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------|----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [claims](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-resources-claims) | array (object) | Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. This field depends on the DynamicResourceAllocation feature gate. This field is immutable. It can only be set for containers. |
| [limits](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-resources-limits) | object | Limits describes the maximum amount of compute resources allowed. More info: [https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) |
| [requests](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-resources-requests) | object | 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. Requests cannot exceed Limits. More info: [https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) |
### .spec.datacenter.racks[].resources.claims[]
#### Description
ResourceClaim references one entry in PodSpec.ResourceClaims.
#### Type
object
| Property | Type | Description |
|------------|--------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| name | string | Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container. |
| request | string | Request is the name chosen for a request in the referenced claim. If empty, everything from the claim is made available, otherwise only the result of this request. |
### .spec.datacenter.racks[].resources.limits
#### Description
Limits describes the maximum amount of compute resources allowed. More info: [https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/)
#### Type
object
### .spec.datacenter.racks[].resources.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. Requests cannot exceed Limits. More info: [https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/)
#### Type
object
### .spec.datacenter.racks[].storage
#### Description
storage describes the underlying storage that Scylla will consume.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| capacity | string | capacity describes the requested size of each persistent volume. |
| [metadata](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-storage-metadata) | object | metadata controls shared metadata for the volume claim for this rack. At this point, the values are applied only for the initial claim and are not reconciled during its lifetime. Note that this may get fixed in the future and this behaviour shouldn’t be relied on in any way. |
| storageClassName | string | storageClassName is the name of a storageClass to request. |
### .spec.datacenter.racks[].storage.metadata
#### Description
metadata controls shared metadata for the volume claim for this rack. At this point, the values are applied only for the initial claim and are not reconciled during its lifetime. Note that this may get fixed in the future and this behaviour shouldn’t be relied on in any way.
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------------|--------|-----------------------------------------------------------------------------------------|
| [annotations](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-storage-metadata-annotations) | object | annotations is a custom key value map that gets merged with managed object annotations. |
| [labels](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-storage-metadata-labels) | object | labels is a custom key value map that gets merged with managed object labels. |
### .spec.datacenter.racks[].storage.metadata.annotations
#### Description
annotations is a custom key value map that gets merged with managed object annotations.
#### Type
object
### .spec.datacenter.racks[].storage.metadata.labels
#### Description
labels is a custom key value map that gets merged with managed object labels.
#### Type
object
### .spec.datacenter.racks[].volumeMounts[]
#### Description
VolumeMount describes a mounting of a Volume within a container.
#### Type
object
| Property | Type | Description |
|-------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| mountPath | string | Path within the container at which the volume should be mounted. Must not contain ‘:’. |
| mountPropagation | string | 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. When RecursiveReadOnly is set to IfPossible or to Enabled, MountPropagation must be None or unspecified (which defaults to None). |
| name | string | This must match the Name of a Volume. |
| readOnly | boolean | Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false. |
| recursiveReadOnly | string | RecursiveReadOnly specifies whether read-only mounts should be handled recursively. If ReadOnly is false, this field has no meaning and must be unspecified. If ReadOnly is true, and this field is set to Disabled, the mount is not made recursively read-only. If this field is set to IfPossible, the mount is made recursively read-only, if it is supported by the container runtime. If this field is set to Enabled, the mount is made recursively read-only if it is supported by the container runtime, otherwise the pod will not be started and an error will be generated to indicate the reason. If this field is set to IfPossible or Enabled, MountPropagation must be set to None (or be unspecified, which defaults to None). If this field is not specified, it is treated as an equivalent of Disabled. |
| subPath | string | Path within the volume from which the container’s volume should be mounted. Defaults to “” (volume’s root). |
| subPathExpr | string | 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. |
### .spec.datacenter.racks[].volumes[]
#### Description
Volume represents a named volume in a pod that may be accessed by any container in the pod.
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------------------------|--------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [awsElasticBlockStore](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-awselasticblockstore) | object | awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet’s host machine and then exposed to the pod. Deprecated: AWSElasticBlockStore is deprecated. All operations for the in-tree awsElasticBlockStore type are redirected to the ebs.csi.aws.com CSI driver. More info: [https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore](https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore) |
| [azureDisk](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-azuredisk) | object | azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod. Deprecated: AzureDisk is deprecated. All operations for the in-tree azureDisk type are redirected to the disk.csi.azure.com CSI driver. |
| [azureFile](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-azurefile) | object | azureFile represents an Azure File Service mount on the host and bind mount to the pod. Deprecated: AzureFile is deprecated. All operations for the in-tree azureFile type are redirected to the file.csi.azure.com CSI driver. |
| [cephfs](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-cephfs) | object | cephFS represents a Ceph FS mount on the host that shares a pod’s lifetime. Deprecated: CephFS is deprecated and the in-tree cephfs type is no longer supported. |
| [cinder](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-cinder) | object | cinder represents a cinder volume attached and mounted on kubelets host machine. Deprecated: Cinder is deprecated. All operations for the in-tree cinder type are redirected to the cinder.csi.openstack.org CSI driver. More info: [https://examples.k8s.io/mysql-cinder-pd/README.md](https://examples.k8s.io/mysql-cinder-pd/README.md) |
| [configMap](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-configmap) | object | configMap represents a configMap that should populate this volume |
| [csi](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-csi) | object | csi (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers. |
| [downwardAPI](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-downwardapi) | object | downwardAPI represents downward API about the pod that should populate this volume |
| [emptyDir](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-emptydir) | object | emptyDir represents a temporary directory that shares a pod’s lifetime. More info: [https://kubernetes.io/docs/concepts/storage/volumes#emptydir](https://kubernetes.io/docs/concepts/storage/volumes#emptydir) |
| [ephemeral](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-ephemeral) | object | 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. Use this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity tracking are needed, c) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through a PersistentVolumeClaim (see EphemeralVolumeSource for more information on the connection between this volume type and PersistentVolumeClaim). Use PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod. Use 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. A pod can use both types of ephemeral volumes and persistent volumes at the same time. |
| [fc](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-fc) | object | fc represents a Fibre Channel resource that is attached to a kubelet’s host machine and then exposed to the pod. |
| [flexVolume](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-flexvolume) | object | flexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin. Deprecated: FlexVolume is deprecated. Consider using a CSIDriver instead. |
| [flocker](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-flocker) | object | flocker represents a Flocker volume attached to a kubelet’s host machine. This depends on the Flocker control service being running. Deprecated: Flocker is deprecated and the in-tree flocker type is no longer supported. |
| [gcePersistentDisk](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-gcepersistentdisk) | object | gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet’s host machine and then exposed to the pod. Deprecated: GCEPersistentDisk is deprecated. All operations for the in-tree gcePersistentDisk type are redirected to the pd.csi.storage.gke.io CSI driver. More info: [https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk](https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk) |
| [gitRepo](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-gitrepo) | object | 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. |
| [glusterfs](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-glusterfs) | object | glusterfs represents a Glusterfs mount on the host that shares a pod’s lifetime. Deprecated: Glusterfs is deprecated and the in-tree glusterfs type is no longer supported. |
| [hostPath](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-hostpath) | object | 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](https://kubernetes.io/docs/concepts/storage/volumes#hostpath) |
| [image](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-image) | object | image represents an OCI object (a container image or artifact) pulled and mounted on the kubelet’s host machine. The volume is resolved at pod startup depending on which PullPolicy value is provided: - Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. - Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn’t present. - IfNotPresent: the kubelet pulls if the reference isn’t already present on disk. Container creation will fail if the reference isn’t present and the pull fails. The volume gets re-resolved if the pod gets deleted and recreated, which means that new remote content will become available on pod recreation. A failure to resolve or pull the image during pod startup will block containers from starting and may add significant latency. Failures will be retried using normal volume backoff and will be reported on the pod reason and message. The types of objects that may be mounted by this volume are defined by the container runtime implementation on a host machine and at minimum must include all valid types supported by the container image field. The OCI object gets mounted in a single directory (spec.containers[\*].volumeMounts.mountPath) by merging the manifest layers in the same way as for container images. The volume will be mounted read-only (ro). Sub path mounts for containers are not supported (spec.containers[\*].volumeMounts.subpath) before 1.33. The field spec.securityContext.fsGroupChangePolicy has no effect on this volume type. |
| [iscsi](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-iscsi) | object | iscsi represents an ISCSI 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/#iscsi](https://kubernetes.io/docs/concepts/storage/volumes/#iscsi) |
| name | string | 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](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names) |
| [nfs](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-nfs) | object | nfs represents an NFS mount on the host that shares a pod’s lifetime More info: [https://kubernetes.io/docs/concepts/storage/volumes#nfs](https://kubernetes.io/docs/concepts/storage/volumes#nfs) |
| [persistentVolumeClaim](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-persistentvolumeclaim) | object | persistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: [https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims](https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims) |
| [photonPersistentDisk](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-photonpersistentdisk) | object | photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine. Deprecated: PhotonPersistentDisk is deprecated and the in-tree photonPersistentDisk type is no longer supported. |
| [portworxVolume](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-portworxvolume) | object | portworxVolume represents a portworx volume attached and mounted on kubelets host machine. Deprecated: PortworxVolume is deprecated. All operations for the in-tree portworxVolume type are redirected to the pxd.portworx.com CSI driver. |
| [projected](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-projected) | object | projected items for all in one resources secrets, configmaps, and downward API |
| [quobyte](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-quobyte) | object | quobyte represents a Quobyte mount on the host that shares a pod’s lifetime. Deprecated: Quobyte is deprecated and the in-tree quobyte type is no longer supported. |
| [rbd](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-rbd) | object | rbd represents a Rados Block Device mount on the host that shares a pod’s lifetime. Deprecated: RBD is deprecated and the in-tree rbd type is no longer supported. |
| [scaleIO](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-scaleio) | object | scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes. Deprecated: ScaleIO is deprecated and the in-tree scaleIO type is no longer supported. |
| [secret](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-secret) | object | secret represents a secret that should populate this volume. More info: [https://kubernetes.io/docs/concepts/storage/volumes#secret](https://kubernetes.io/docs/concepts/storage/volumes#secret) |
| [storageos](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-storageos) | object | storageOS represents a StorageOS volume attached and mounted on Kubernetes nodes. Deprecated: StorageOS is deprecated and the in-tree storageos type is no longer supported. |
| [vsphereVolume](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-vspherevolume) | object | vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine. Deprecated: VsphereVolume is deprecated. All operations for the in-tree vsphereVolume type are redirected to the csi.vsphere.vmware.com CSI driver. |
### .spec.datacenter.racks[].volumes[].awsElasticBlockStore
#### Description
awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet’s host machine and then exposed to the pod. Deprecated: AWSElasticBlockStore is deprecated. All operations for the in-tree awsElasticBlockStore type are redirected to the ebs.csi.aws.com CSI driver. More info: [https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore](https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore)
#### Type
object
| Property | Type | Description |
|------------|---------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| fsType | string | 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](https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore) |
| partition | integer | 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). |
| readOnly | boolean | readOnly value true will force the readOnly setting in VolumeMounts. More info: [https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore](https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore) |
| volumeID | string | volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: [https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore](https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore) |
### .spec.datacenter.racks[].volumes[].azureDisk
#### Description
azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod. Deprecated: AzureDisk is deprecated. All operations for the in-tree azureDisk type are redirected to the disk.csi.azure.com CSI driver.
#### Type
object
| Property | Type | Description |
|-------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| cachingMode | string | cachingMode is the Host Caching mode: None, Read Only, Read Write. |
| diskName | string | diskName is the Name of the data disk in the blob storage |
| diskURI | string | diskURI is the URI of data disk in the blob storage |
| fsType | string | 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. |
| kind | string | 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 |
| readOnly | boolean | readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. |
### .spec.datacenter.racks[].volumes[].azureFile
#### Description
azureFile represents an Azure File Service mount on the host and bind mount to the pod. Deprecated: AzureFile is deprecated. All operations for the in-tree azureFile type are redirected to the file.csi.azure.com CSI driver.
#### Type
object
| Property | Type | Description |
|------------|---------|---------------------------------------------------------------------------------------------------------|
| readOnly | boolean | readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. |
| secretName | string | secretName is the name of secret that contains Azure Storage Account Name and Key |
| shareName | string | shareName is the azure share Name |
### .spec.datacenter.racks[].volumes[].cephfs
#### Description
cephFS represents a Ceph FS mount on the host that shares a pod’s lifetime. Deprecated: CephFS is deprecated and the in-tree cephfs type is no longer supported.
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------|----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| monitors | array (string) | monitors is Required: Monitors is a collection of Ceph monitors More info: [https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it](https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it) |
| path | string | path is Optional: Used as the mounted root, rather than the full Ceph tree, default is / |
| readOnly | boolean | 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](https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it) |
| secretFile | string | 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](https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it) |
| [secretRef](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-cephfs-secretref) | object | 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](https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it) |
| user | string | 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](https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it) |
### .spec.datacenter.racks[].volumes[].cephfs.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](https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it)
#### Type
object
| Property | Type | Description |
|------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| name | string | Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: [https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names) |
### .spec.datacenter.racks[].volumes[].cinder
#### Description
cinder represents a cinder volume attached and mounted on kubelets host machine. Deprecated: Cinder is deprecated. All operations for the in-tree cinder type are redirected to the cinder.csi.openstack.org CSI driver. More info: [https://examples.k8s.io/mysql-cinder-pd/README.md](https://examples.k8s.io/mysql-cinder-pd/README.md)
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| fsType | string | 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](https://examples.k8s.io/mysql-cinder-pd/README.md) |
| readOnly | boolean | 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](https://examples.k8s.io/mysql-cinder-pd/README.md) |
| [secretRef](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-cinder-secretref) | object | secretRef is optional: points to a secret object containing parameters used to connect to OpenStack. |
| volumeID | string | volumeID used to identify the volume in cinder. More info: [https://examples.k8s.io/mysql-cinder-pd/README.md](https://examples.k8s.io/mysql-cinder-pd/README.md) |
### .spec.datacenter.racks[].volumes[].cinder.secretRef
#### Description
secretRef is optional: points to a secret object containing parameters used to connect to OpenStack.
#### Type
object
| Property | Type | Description |
|------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| name | string | Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: [https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names) |
### .spec.datacenter.racks[].volumes[].configMap
#### Description
configMap represents a configMap that should populate this volume
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------|----------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| defaultMode | integer | 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. |
| [items](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-configmap-items) | array (object) | 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 ‘..’. |
| name | string | Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: [https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names) |
| optional | boolean | optional specify whether the ConfigMap or its keys must be defined |
### .spec.datacenter.racks[].volumes[].configMap.items[]
#### Description
Maps a string key to a path within a volume.
#### Type
object
| Property | Type | Description |
|------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the key to project. |
| mode | integer | 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. |
| path | string | 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 ‘..’. |
### .spec.datacenter.racks[].volumes[].csi
#### Description
csi (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| driver | string | 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. |
| fsType | string | 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. |
| [nodePublishSecretRef](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-csi-nodepublishsecretref) | object | 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. |
| readOnly | boolean | readOnly specifies a read-only configuration for the volume. Defaults to false (read/write). |
| [volumeAttributes](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-csi-volumeattributes) | object | volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver’s documentation for supported values. |
### .spec.datacenter.racks[].volumes[].csi.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.
#### Type
object
| Property | Type | Description |
|------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| name | string | Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: [https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names) |
### .spec.datacenter.racks[].volumes[].csi.volumeAttributes
#### Description
volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver’s documentation for supported values.
#### Type
object
### .spec.datacenter.racks[].volumes[].downwardAPI
#### Description
downwardAPI represents downward API about the pod that should populate this volume
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------|----------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| defaultMode | integer | 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. |
| [items](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-downwardapi-items) | array (object) | Items is a list of downward API volume file |
### .spec.datacenter.racks[].volumes[].downwardAPI.items[]
#### Description
DownwardAPIVolumeFile represents information to create the file containing the pod field
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [fieldRef](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-downwardapi-items-fieldref) | object | Required: Selects a field of the pod: only annotations, labels, name, namespace and uid are supported. |
| mode | integer | 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. |
| path | string | 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 ‘..’ |
| [resourceFieldRef](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-downwardapi-items-resourcefieldref) | object | Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported. |
### .spec.datacenter.racks[].volumes[].downwardAPI.items[].fieldRef
#### Description
Required: Selects a field of the pod: only annotations, labels, name, namespace and uid are supported.
#### Type
object
| Property | Type | Description |
|------------|--------|-------------------------------------------------------------------------------|
| apiVersion | string | Version of the schema the FieldPath is written in terms of, defaults to “v1”. |
| fieldPath | string | Path of the field to select in the specified API version. |
### .spec.datacenter.racks[].volumes[].downwardAPI.items[].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.
#### Type
object
| Property | Type | Description |
|---------------|--------|-----------------------------------------------------------------------|
| containerName | string | Container name: required for volumes, optional for env vars |
| divisor | | Specifies the output format of the exposed resources, defaults to “1” |
| resource | string | Required: resource to select |
### .spec.datacenter.racks[].volumes[].emptyDir
#### Description
emptyDir represents a temporary directory that shares a pod’s lifetime. More info: [https://kubernetes.io/docs/concepts/storage/volumes#emptydir](https://kubernetes.io/docs/concepts/storage/volumes#emptydir)
#### Type
object
| Property | Type | Description |
|------------|--------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| medium | string | 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](https://kubernetes.io/docs/concepts/storage/volumes#emptydir) |
| sizeLimit | | 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: [https://kubernetes.io/docs/concepts/storage/volumes#emptydir](https://kubernetes.io/docs/concepts/storage/volumes#emptydir) |
### .spec.datacenter.racks[].volumes[].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. Use this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity tracking are needed, c) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through a PersistentVolumeClaim (see EphemeralVolumeSource for more information on the connection between this volume type and PersistentVolumeClaim). Use PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod. Use 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. A pod can use both types of ephemeral volumes and persistent volumes at the same time.
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------------------------------|--------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [volumeClaimTemplate](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-ephemeral-volumeclaimtemplate) | object | 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). An 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. This field is read-only and no changes will be made by Kubernetes to the PVC after it has been created. Required, must not be nil. |
### .spec.datacenter.racks[].volumes[].ephemeral.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). An 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. This field is read-only and no changes will be made by Kubernetes to the PVC after it has been created. Required, must not be nil.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------|--------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [metadata](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-ephemeral-volumeclaimtemplate-metadata) | object | 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. |
| [spec](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-ephemeral-volumeclaimtemplate-spec) | object | 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. |
### .spec.datacenter.racks[].volumes[].ephemeral.volumeClaimTemplate.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.
#### Type
object
### .spec.datacenter.racks[].volumes[].ephemeral.volumeClaimTemplate.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.
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------------------------------------------|----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| accessModes | array (string) | accessModes contains the desired access modes the volume should have. More info: [https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1](https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1) |
| [dataSource](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-ephemeral-volumeclaimtemplate-spec-datasource) | object | 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. When the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef, and dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified. If the namespace is specified, then dataSourceRef will not be copied to dataSource. |
| [dataSourceRef](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-ephemeral-volumeclaimtemplate-spec-datasourceref) | object | dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any 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, when namespace isn’t specified in dataSourceRef, 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. When namespace is specified in dataSourceRef, dataSource isn’t set to the same value and must be empty. There are three important differences between dataSource and dataSourceRef: \* While dataSource only allows two specific types of objects, dataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. \* While dataSource ignores disallowed values (dropping them), dataSourceRef preserves all values, and generates an error if a disallowed value is specified. \* While dataSource only allows local objects, dataSourceRef allows objects in any namespaces. (Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. (Alpha) Using the namespace field of dataSourceRef requires the CrossNamespaceVolumeDataSource feature gate to be enabled. |
| [resources](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-ephemeral-volumeclaimtemplate-spec-resources) | object | resources represents the minimum resources the volume should have. 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](https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources) |
| [selector](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-ephemeral-volumeclaimtemplate-spec-selector) | object | selector is a label query over volumes to consider for binding. |
| storageClassName | string | storageClassName is the name of the StorageClass required by the claim. More info: [https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1](https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1) |
| volumeAttributesClassName | string | volumeAttributesClassName may be used to set the VolumeAttributesClass used by this claim. If specified, the CSI driver will create or update the volume with the attributes defined in the corresponding VolumeAttributesClass. This has a different purpose than storageClassName, it can be changed after the claim is created. An empty string or nil value indicates that no VolumeAttributesClass will be applied to the claim. If the claim enters an Infeasible error state, this field can be reset to its previous value (including nil) to cancel the modification. If the resource referred to by volumeAttributesClass does not exist, this PersistentVolumeClaim will be set to a Pending state, as reflected by the modifyVolumeStatus field, until such as a resource exists. More info: [https://kubernetes.io/docs/concepts/storage/volume-attributes-classes/](https://kubernetes.io/docs/concepts/storage/volume-attributes-classes/) |
| volumeMode | string | volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec. |
| volumeName | string | volumeName is the binding reference to the PersistentVolume backing this claim. |
### .spec.datacenter.racks[].volumes[].ephemeral.volumeClaimTemplate.spec.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. When the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef, and dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified. If the namespace is specified, then dataSourceRef will not be copied to dataSource.
#### Type
object
| Property | Type | Description |
|------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| apiGroup | string | 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. |
| kind | string | Kind is the type of resource being referenced |
| name | string | Name is the name of resource being referenced |
### .spec.datacenter.racks[].volumes[].ephemeral.volumeClaimTemplate.spec.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 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, when namespace isn’t specified in dataSourceRef, 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. When namespace is specified in dataSourceRef, dataSource isn’t set to the same value and must be empty. There are three important differences between dataSource and dataSourceRef: \* While dataSource only allows two specific types of objects, dataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. \* While dataSource ignores disallowed values (dropping them), dataSourceRef preserves all values, and generates an error if a disallowed value is specified. \* While dataSource only allows local objects, dataSourceRef allows objects in any namespaces. (Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. (Alpha) Using the namespace field of dataSourceRef requires the CrossNamespaceVolumeDataSource feature gate to be enabled.
#### Type
object
| Property | Type | Description |
|------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| apiGroup | string | 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. |
| kind | string | Kind is the type of resource being referenced |
| name | string | Name is the name of resource being referenced |
| namespace | string | Namespace is the namespace of resource being referenced Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace’s owner to accept the reference. See the ReferenceGrant documentation for details. (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled. |
### .spec.datacenter.racks[].volumes[].ephemeral.volumeClaimTemplate.spec.resources
#### Description
resources represents the minimum resources the volume should have. 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](https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources)
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------------------------------------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [limits](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-ephemeral-volumeclaimtemplate-spec-resources-limits) | object | Limits describes the maximum amount of compute resources allowed. More info: [https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) |
| [requests](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-ephemeral-volumeclaimtemplate-spec-resources-requests) | object | 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. Requests cannot exceed Limits. More info: [https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) |
### .spec.datacenter.racks[].volumes[].ephemeral.volumeClaimTemplate.spec.resources.limits
#### Description
Limits describes the maximum amount of compute resources allowed. More info: [https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/)
#### Type
object
### .spec.datacenter.racks[].volumes[].ephemeral.volumeClaimTemplate.spec.resources.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. Requests cannot exceed Limits. More info: [https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/)
#### Type
object
### .spec.datacenter.racks[].volumes[].ephemeral.volumeClaimTemplate.spec.selector
#### Description
selector is a label query over volumes to consider for binding.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-ephemeral-volumeclaimtemplate-spec-selector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-ephemeral-volumeclaimtemplate-spec-selector-matchlabels) | object | 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. |
### .spec.datacenter.racks[].volumes[].ephemeral.volumeClaimTemplate.spec.selector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenter.racks[].volumes[].ephemeral.volumeClaimTemplate.spec.selector.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
### .spec.datacenter.racks[].volumes[].fc
#### Description
fc represents a Fibre Channel resource that is attached to a kubelet’s host machine and then exposed to the pod.
#### Type
object
| Property | Type | Description |
|------------|----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| fsType | string | 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. |
| lun | integer | lun is Optional: FC target lun number |
| readOnly | boolean | readOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. |
| targetWWNs | array (string) | targetWWNs is Optional: FC target worldwide names (WWNs) |
| wwids | array (string) | wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously. |
### .spec.datacenter.racks[].volumes[].flexVolume
#### Description
flexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin. Deprecated: FlexVolume is deprecated. Consider using a CSIDriver instead.
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| driver | string | driver is the name of the driver to use for this volume. |
| fsType | string | 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. |
| [options](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-flexvolume-options) | object | options is Optional: this field holds extra command options if any. |
| readOnly | boolean | readOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. |
| [secretRef](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-flexvolume-secretref) | object | 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. |
### .spec.datacenter.racks[].volumes[].flexVolume.options
#### Description
options is Optional: this field holds extra command options if any.
#### Type
object
### .spec.datacenter.racks[].volumes[].flexVolume.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.
#### Type
object
| Property | Type | Description |
|------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| name | string | Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: [https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names) |
### .spec.datacenter.racks[].volumes[].flocker
#### Description
flocker represents a Flocker volume attached to a kubelet’s host machine. This depends on the Flocker control service being running. Deprecated: Flocker is deprecated and the in-tree flocker type is no longer supported.
#### Type
object
| Property | Type | Description |
|-------------|--------|-----------------------------------------------------------------------------------------------------------------------------|
| datasetName | string | datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated |
| datasetUUID | string | datasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset |
### .spec.datacenter.racks[].volumes[].gcePersistentDisk
#### Description
gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet’s host machine and then exposed to the pod. Deprecated: GCEPersistentDisk is deprecated. All operations for the in-tree gcePersistentDisk type are redirected to the pd.csi.storage.gke.io CSI driver. More info: [https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk](https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk)
#### Type
object
| Property | Type | Description |
|------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| fsType | string | 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](https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk) |
| partition | integer | 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](https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk) |
| pdName | string | 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](https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk) |
| readOnly | boolean | readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: [https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk](https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk) |
### .spec.datacenter.racks[].volumes[].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.
#### Type
object
| Property | Type | Description |
|------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| directory | string | 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. |
| repository | string | repository is the URL |
| revision | string | revision is the commit hash for the specified revision. |
### .spec.datacenter.racks[].volumes[].glusterfs
#### Description
glusterfs represents a Glusterfs mount on the host that shares a pod’s lifetime. Deprecated: Glusterfs is deprecated and the in-tree glusterfs type is no longer supported.
#### Type
object
| Property | Type | Description |
|------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| endpoints | string | endpoints is the endpoint name that details Glusterfs topology. |
| path | string | path is the Glusterfs volume path. More info: [https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod](https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod) |
| readOnly | boolean | 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](https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod) |
### .spec.datacenter.racks[].volumes[].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](https://kubernetes.io/docs/concepts/storage/volumes#hostpath)
#### Type
object
| Property | Type | Description |
|------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| path | string | 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](https://kubernetes.io/docs/concepts/storage/volumes#hostpath) |
| type | string | type for HostPath Volume Defaults to “” More info: [https://kubernetes.io/docs/concepts/storage/volumes#hostpath](https://kubernetes.io/docs/concepts/storage/volumes#hostpath) |
### .spec.datacenter.racks[].volumes[].image
#### Description
image represents an OCI object (a container image or artifact) pulled and mounted on the kubelet’s host machine. The volume is resolved at pod startup depending on which PullPolicy value is provided: - Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. - Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn’t present. - IfNotPresent: the kubelet pulls if the reference isn’t already present on disk. Container creation will fail if the reference isn’t present and the pull fails. The volume gets re-resolved if the pod gets deleted and recreated, which means that new remote content will become available on pod recreation. A failure to resolve or pull the image during pod startup will block containers from starting and may add significant latency. Failures will be retried using normal volume backoff and will be reported on the pod reason and message. The types of objects that may be mounted by this volume are defined by the container runtime implementation on a host machine and at minimum must include all valid types supported by the container image field. The OCI object gets mounted in a single directory (spec.containers[\*].volumeMounts.mountPath) by merging the manifest layers in the same way as for container images. The volume will be mounted read-only (ro). Sub path mounts for containers are not supported (spec.containers[\*].volumeMounts.subpath) before 1.33. The field spec.securityContext.fsGroupChangePolicy has no effect on this volume type.
#### Type
object
| Property | Type | Description |
|------------|--------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| pullPolicy | string | Policy for pulling OCI objects. Possible values are: Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn’t present. IfNotPresent: the kubelet pulls if the reference isn’t already present on disk. Container creation will fail if the reference isn’t present and the pull fails. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. |
| reference | string | Required: Image or artifact reference to be used. Behaves in the same way as pod.spec.containers[\*].image. Pull secrets will be assembled in the same way as for the container image by looking up node credentials, SA image pull secrets, and pod spec image pull secrets. More info: [https://kubernetes.io/docs/concepts/containers/images](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. |
### .spec.datacenter.racks[].volumes[].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://kubernetes.io/docs/concepts/storage/volumes/#iscsi](https://kubernetes.io/docs/concepts/storage/volumes/#iscsi)
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| chapAuthDiscovery | boolean | chapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication |
| chapAuthSession | boolean | chapAuthSession defines whether support iSCSI Session CHAP authentication |
| fsType | string | 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](https://kubernetes.io/docs/concepts/storage/volumes#iscsi) |
| initiatorName | string | initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection. |
| iqn | string | iqn is the target iSCSI Qualified Name. |
| iscsiInterface | string | iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to ‘default’ (tcp). |
| lun | integer | lun represents iSCSI Target Lun number. |
| portals | array (string) | 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). |
| readOnly | boolean | readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. |
| [secretRef](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-iscsi-secretref) | object | secretRef is the CHAP Secret for iSCSI target and initiator authentication |
| targetPortal | string | 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). |
### .spec.datacenter.racks[].volumes[].iscsi.secretRef
#### Description
secretRef is the CHAP Secret for iSCSI target and initiator authentication
#### Type
object
| Property | Type | Description |
|------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| name | string | Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: [https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names) |
### .spec.datacenter.racks[].volumes[].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](https://kubernetes.io/docs/concepts/storage/volumes#nfs)
#### Type
object
| Property | Type | Description |
|------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| path | string | path that is exported by the NFS server. More info: [https://kubernetes.io/docs/concepts/storage/volumes#nfs](https://kubernetes.io/docs/concepts/storage/volumes#nfs) |
| readOnly | boolean | 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](https://kubernetes.io/docs/concepts/storage/volumes#nfs) |
| server | string | server is the hostname or IP address of the NFS server. More info: [https://kubernetes.io/docs/concepts/storage/volumes#nfs](https://kubernetes.io/docs/concepts/storage/volumes#nfs) |
### .spec.datacenter.racks[].volumes[].persistentVolumeClaim
#### Description
persistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: [https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims](https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims)
#### Type
object
| Property | Type | Description |
|------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| claimName | string | 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](https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims) |
| readOnly | boolean | readOnly Will force the ReadOnly setting in VolumeMounts. Default false. |
### .spec.datacenter.racks[].volumes[].photonPersistentDisk
#### Description
photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine. Deprecated: PhotonPersistentDisk is deprecated and the in-tree photonPersistentDisk type is no longer supported.
#### Type
object
| Property | Type | Description |
|------------|--------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| fsType | string | 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. |
| pdID | string | pdID is the ID that identifies Photon Controller persistent disk |
### .spec.datacenter.racks[].volumes[].portworxVolume
#### Description
portworxVolume represents a portworx volume attached and mounted on kubelets host machine. Deprecated: PortworxVolume is deprecated. All operations for the in-tree portworxVolume type are redirected to the pxd.portworx.com CSI driver.
#### Type
object
| Property | Type | Description |
|------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| fsType | string | 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. |
| readOnly | boolean | readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. |
| volumeID | string | volumeID uniquely identifies a Portworx volume |
### .spec.datacenter.racks[].volumes[].projected
#### Description
projected items for all in one resources secrets, configmaps, and downward API
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| defaultMode | integer | 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. |
| [sources](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-projected-sources) | array (object) | sources is the list of volume projections. Each entry in this list handles one source. |
### .spec.datacenter.racks[].volumes[].projected.sources[]
#### Description
Projection that may be projected along with other supported volume types. Exactly one of these fields must be set.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [clusterTrustBundle](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-projected-sources-clustertrustbundle) | object | ClusterTrustBundle allows a pod to access the .spec.trustBundle field of ClusterTrustBundle objects in an auto-updating file. Alpha, gated by the ClusterTrustBundleProjection feature gate. ClusterTrustBundle objects can either be selected by name, or by the combination of signer name and a label selector. Kubelet performs aggressive normalization of the PEM contents written into the pod filesystem. Esoteric PEM features such as inter-block comments and block headers are stripped. Certificates are deduplicated. The ordering of certificates within the file is arbitrary, and Kubelet may change the order over time. |
| [configMap](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-projected-sources-configmap) | object | configMap information about the configMap data to project |
| [downwardAPI](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-projected-sources-downwardapi) | object | downwardAPI information about the downwardAPI data to project |
| [podCertificate](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-projected-sources-podcertificate) | object | Projects an auto-rotating credential bundle (private key and certificate chain) that the pod can use either as a TLS client or server. Kubelet generates a private key and uses it to send a PodCertificateRequest to the named signer. Once the signer approves the request and issues a certificate chain, Kubelet writes the key and certificate chain to the pod filesystem. The pod does not start until certificates have been issued for each podCertificate projected volume source in its spec. Kubelet will begin trying to rotate the certificate at the time indicated by the signer using the PodCertificateRequest.Status.BeginRefreshAt timestamp. Kubelet can write a single file, indicated by the credentialBundlePath field, or separate files, indicated by the keyPath and certificateChainPath fields. The credential bundle is a single file in PEM format. The first PEM entry is the private key (in PKCS#8 format), and the remaining PEM entries are the certificate chain issued by the signer (typically, signers will return their certificate chain in leaf-to-root order). Prefer using the credential bundle format, since your application code can read it atomically. If you use keyPath and certificateChainPath, your application must make two separate file reads. If these coincide with a certificate rotation, it is possible that the private key and leaf certificate you read may not correspond to each other. Your application will need to check for this condition, and re-read until they are consistent. The named signer controls chooses the format of the certificate it issues; consult the signer implementation’s documentation to learn how to use the certificates it issues. |
| [secret](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-projected-sources-secret) | object | secret information about the secret data to project |
| [serviceAccountToken](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-projected-sources-serviceaccounttoken) | object | serviceAccountToken is information about the serviceAccountToken data to project |
### .spec.datacenter.racks[].volumes[].projected.sources[].clusterTrustBundle
#### Description
ClusterTrustBundle allows a pod to access the .spec.trustBundle field of ClusterTrustBundle objects in an auto-updating file. Alpha, gated by the ClusterTrustBundleProjection feature gate. ClusterTrustBundle objects can either be selected by name, or by the combination of signer name and a label selector. Kubelet performs aggressive normalization of the PEM contents written into the pod filesystem. Esoteric PEM features such as inter-block comments and block headers are stripped. Certificates are deduplicated. The ordering of certificates within the file is arbitrary, and Kubelet may change the order over time.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [labelSelector](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-projected-sources-clustertrustbundle-labelselector) | object | Select all ClusterTrustBundles that match this label selector. Only has effect if signerName is set. Mutually-exclusive with name. If unset, interpreted as “match nothing”. If set but empty, interpreted as “match everything”. |
| name | string | Select a single ClusterTrustBundle by object name. Mutually-exclusive with signerName and labelSelector. |
| optional | boolean | If true, don’t block pod startup if the referenced ClusterTrustBundle(s) aren’t available. If using name, then the named ClusterTrustBundle is allowed not to exist. If using signerName, then the combination of signerName and labelSelector is allowed to match zero ClusterTrustBundles. |
| path | string | Relative path from the volume root to write the bundle. |
| signerName | string | Select all ClusterTrustBundles that match this signer name. Mutually-exclusive with name. The contents of all selected ClusterTrustBundles will be unified and deduplicated. |
### .spec.datacenter.racks[].volumes[].projected.sources[].clusterTrustBundle.labelSelector
#### Description
Select all ClusterTrustBundles that match this label selector. Only has effect if signerName is set. Mutually-exclusive with name. If unset, interpreted as “match nothing”. If set but empty, interpreted as “match everything”.
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-projected-sources-clustertrustbundle-labelselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-projected-sources-clustertrustbundle-labelselector-matchlabels) | object | 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. |
### .spec.datacenter.racks[].volumes[].projected.sources[].clusterTrustBundle.labelSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenter.racks[].volumes[].projected.sources[].clusterTrustBundle.labelSelector.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
### .spec.datacenter.racks[].volumes[].projected.sources[].configMap
#### Description
configMap information about the configMap data to project
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------|----------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [items](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-projected-sources-configmap-items) | array (object) | 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 ‘..’. |
| name | string | Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: [https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names) |
| optional | boolean | optional specify whether the ConfigMap or its keys must be defined |
### .spec.datacenter.racks[].volumes[].projected.sources[].configMap.items[]
#### Description
Maps a string key to a path within a volume.
#### Type
object
| Property | Type | Description |
|------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the key to project. |
| mode | integer | 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. |
| path | string | 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 ‘..’. |
### .spec.datacenter.racks[].volumes[].projected.sources[].downwardAPI
#### Description
downwardAPI information about the downwardAPI data to project
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------|----------------|-------------------------------------------|
| [items](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-projected-sources-downwardapi-items) | array (object) | Items is a list of DownwardAPIVolume file |
### .spec.datacenter.racks[].volumes[].projected.sources[].downwardAPI.items[]
#### Description
DownwardAPIVolumeFile represents information to create the file containing the pod field
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [fieldRef](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-projected-sources-downwardapi-items-fieldref) | object | Required: Selects a field of the pod: only annotations, labels, name, namespace and uid are supported. |
| mode | integer | 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. |
| path | string | 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 ‘..’ |
| [resourceFieldRef](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-projected-sources-downwardapi-items-resourcefieldref) | object | Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported. |
### .spec.datacenter.racks[].volumes[].projected.sources[].downwardAPI.items[].fieldRef
#### Description
Required: Selects a field of the pod: only annotations, labels, name, namespace and uid are supported.
#### Type
object
| Property | Type | Description |
|------------|--------|-------------------------------------------------------------------------------|
| apiVersion | string | Version of the schema the FieldPath is written in terms of, defaults to “v1”. |
| fieldPath | string | Path of the field to select in the specified API version. |
### .spec.datacenter.racks[].volumes[].projected.sources[].downwardAPI.items[].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.
#### Type
object
| Property | Type | Description |
|---------------|--------|-----------------------------------------------------------------------|
| containerName | string | Container name: required for volumes, optional for env vars |
| divisor | | Specifies the output format of the exposed resources, defaults to “1” |
| resource | string | Required: resource to select |
### .spec.datacenter.racks[].volumes[].projected.sources[].podCertificate
#### Description
Projects an auto-rotating credential bundle (private key and certificate chain) that the pod can use either as a TLS client or server. Kubelet generates a private key and uses it to send a PodCertificateRequest to the named signer. Once the signer approves the request and issues a certificate chain, Kubelet writes the key and certificate chain to the pod filesystem. The pod does not start until certificates have been issued for each podCertificate projected volume source in its spec. Kubelet will begin trying to rotate the certificate at the time indicated by the signer using the PodCertificateRequest.Status.BeginRefreshAt timestamp. Kubelet can write a single file, indicated by the credentialBundlePath field, or separate files, indicated by the keyPath and certificateChainPath fields. The credential bundle is a single file in PEM format. The first PEM entry is the private key (in PKCS#8 format), and the remaining PEM entries are the certificate chain issued by the signer (typically, signers will return their certificate chain in leaf-to-root order). Prefer using the credential bundle format, since your application code can read it atomically. If you use keyPath and certificateChainPath, your application must make two separate file reads. If these coincide with a certificate rotation, it is possible that the private key and leaf certificate you read may not correspond to each other. Your application will need to check for this condition, and re-read until they are consistent. The named signer controls chooses the format of the certificate it issues; consult the signer implementation’s documentation to learn how to use the certificates it issues.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------------|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| certificateChainPath | string | Write the certificate chain at this path in the projected volume. Most applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation. |
| credentialBundlePath | string | Write the credential bundle at this path in the projected volume. The credential bundle is a single file that contains multiple PEM blocks. The first PEM block is a PRIVATE KEY block, containing a PKCS#8 private key. The remaining blocks are CERTIFICATE blocks, containing the issued certificate chain from the signer (leaf and any intermediates). Using credentialBundlePath lets your Pod’s application code make a single atomic read that retrieves a consistent key and certificate chain. If you project them to separate files, your application code will need to additionally check that the leaf certificate was issued to the key. |
| keyPath | string | Write the key at this path in the projected volume. Most applications should use credentialBundlePath. When using keyPath and certificateChainPath, your application needs to check that the key and leaf certificate are consistent, because it is possible to read the files mid-rotation. |
| keyType | string | The type of keypair Kubelet will generate for the pod. Valid values are “RSA3072”, “RSA4096”, “ECDSAP256”, “ECDSAP384”, “ECDSAP521”, and “ED25519”. |
| maxExpirationSeconds | integer | maxExpirationSeconds is the maximum lifetime permitted for the certificate. Kubelet copies this value verbatim into the PodCertificateRequests it generates for this projection. If omitted, kube-apiserver will set it to 86400(24 hours). kube-apiserver will reject values shorter than 3600 (1 hour). The maximum allowable value is 7862400 (91 days). The signer implementation is then free to issue a certificate with any lifetime *shorter* than MaxExpirationSeconds, but no shorter than 3600 seconds (1 hour). This constraint is enforced by kube-apiserver. kubernetes.io signers will never issue certificates with a lifetime longer than 24 hours. |
| signerName | string | Kubelet’s generated CSRs will be addressed to this signer. |
| [userAnnotations](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-projected-sources-podcertificate-userannotations) | object | userAnnotations allow pod authors to pass additional information to the signer implementation. Kubernetes does not restrict or validate this metadata in any way. These values are copied verbatim into the spec.unverifiedUserAnnotations field of the PodCertificateRequest objects that Kubelet creates. Entries are subject to the same validation as object metadata annotations, with the addition that all keys must be domain-prefixed. No restrictions are placed on values, except an overall size limitation on the entire field. Signers should document the keys and values they support. Signers should deny requests that contain keys they do not recognize. |
### .spec.datacenter.racks[].volumes[].projected.sources[].podCertificate.userAnnotations
#### Description
userAnnotations allow pod authors to pass additional information to the signer implementation. Kubernetes does not restrict or validate this metadata in any way. These values are copied verbatim into the spec.unverifiedUserAnnotations field of the PodCertificateRequest objects that Kubelet creates. Entries are subject to the same validation as object metadata annotations, with the addition that all keys must be domain-prefixed. No restrictions are placed on values, except an overall size limitation on the entire field. Signers should document the keys and values they support. Signers should deny requests that contain keys they do not recognize.
#### Type
object
### .spec.datacenter.racks[].volumes[].projected.sources[].secret
#### Description
secret information about the secret data to project
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------------------|----------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [items](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-projected-sources-secret-items) | array (object) | 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 ‘..’. |
| name | string | Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: [https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names) |
| optional | boolean | optional field specify whether the Secret or its key must be defined |
### .spec.datacenter.racks[].volumes[].projected.sources[].secret.items[]
#### Description
Maps a string key to a path within a volume.
#### Type
object
| Property | Type | Description |
|------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the key to project. |
| mode | integer | 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. |
| path | string | 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 ‘..’. |
### .spec.datacenter.racks[].volumes[].projected.sources[].serviceAccountToken
#### Description
serviceAccountToken is information about the serviceAccountToken data to project
#### Type
object
| Property | Type | Description |
|-------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| audience | string | 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. |
| expirationSeconds | integer | 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. |
| path | string | path is the path relative to the mount point of the file to project the token into. |
### .spec.datacenter.racks[].volumes[].quobyte
#### Description
quobyte represents a Quobyte mount on the host that shares a pod’s lifetime. Deprecated: Quobyte is deprecated and the in-tree quobyte type is no longer supported.
#### Type
object
| Property | Type | Description |
|------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| group | string | group to map volume access to Default is no group |
| readOnly | boolean | readOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false. |
| registry | string | 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 |
| tenant | string | tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin |
| user | string | user to map volume access to Defaults to serivceaccount user |
| volume | string | volume is a string that references an already created Quobyte volume by name. |
### .spec.datacenter.racks[].volumes[].rbd
#### Description
rbd represents a Rados Block Device mount on the host that shares a pod’s lifetime. Deprecated: RBD is deprecated and the in-tree rbd type is no longer supported.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------|----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| fsType | string | 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](https://kubernetes.io/docs/concepts/storage/volumes#rbd) |
| image | string | image is the rados image name. More info: [https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it](https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it) |
| keyring | string | 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](https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it) |
| monitors | array (string) | monitors is a collection of Ceph monitors. More info: [https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it](https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it) |
| pool | string | pool is the rados pool name. Default is rbd. More info: [https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it](https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it) |
| readOnly | boolean | 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](https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it) |
| [secretRef](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-rbd-secretref) | object | 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](https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it) |
| user | string | user is the rados user name. Default is admin. More info: [https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it](https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it) |
### .spec.datacenter.racks[].volumes[].rbd.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](https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it)
#### Type
object
| Property | Type | Description |
|------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| name | string | Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: [https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names) |
### .spec.datacenter.racks[].volumes[].scaleIO
#### Description
scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes. Deprecated: ScaleIO is deprecated and the in-tree scaleIO type is no longer supported.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------|
| fsType | string | 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”. |
| gateway | string | gateway is the host address of the ScaleIO API Gateway. |
| protectionDomain | string | protectionDomain is the name of the ScaleIO Protection Domain for the configured storage. |
| readOnly | boolean | readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. |
| [secretRef](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-scaleio-secretref) | object | secretRef references to the secret for ScaleIO user and other sensitive information. If this is not provided, Login operation will fail. |
| sslEnabled | boolean | sslEnabled Flag enable/disable SSL communication with Gateway, default false |
| storageMode | string | storageMode indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. Default is ThinProvisioned. |
| storagePool | string | storagePool is the ScaleIO Storage Pool associated with the protection domain. |
| system | string | system is the name of the storage system as configured in ScaleIO. |
| volumeName | string | volumeName is the name of a volume already created in the ScaleIO system that is associated with this volume source. |
### .spec.datacenter.racks[].volumes[].scaleIO.secretRef
#### Description
secretRef references to the secret for ScaleIO user and other sensitive information. If this is not provided, Login operation will fail.
#### Type
object
| Property | Type | Description |
|------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| name | string | Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: [https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names) |
### .spec.datacenter.racks[].volumes[].secret
#### Description
secret represents a secret that should populate this volume. More info: [https://kubernetes.io/docs/concepts/storage/volumes#secret](https://kubernetes.io/docs/concepts/storage/volumes#secret)
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------|----------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| defaultMode | integer | 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. |
| [items](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-secret-items) | array (object) | 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 ‘..’. |
| optional | boolean | optional field specify whether the Secret or its keys must be defined |
| secretName | string | secretName is the name of the secret in the pod’s namespace to use. More info: [https://kubernetes.io/docs/concepts/storage/volumes#secret](https://kubernetes.io/docs/concepts/storage/volumes#secret) |
### .spec.datacenter.racks[].volumes[].secret.items[]
#### Description
Maps a string key to a path within a volume.
#### Type
object
| Property | Type | Description |
|------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the key to project. |
| mode | integer | 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. |
| path | string | 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 ‘..’. |
### .spec.datacenter.racks[].volumes[].storageos
#### Description
storageOS represents a StorageOS volume attached and mounted on Kubernetes nodes. Deprecated: StorageOS is deprecated and the in-tree storageos type is no longer supported.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| fsType | string | 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. |
| readOnly | boolean | readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. |
| [secretRef](#api-scylla-scylladb-com-scyllaclusters-v1-spec-datacenter-racks-volumes-storageos-secretref) | object | secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted. |
| volumeName | string | volumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace. |
| volumeNamespace | string | 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. |
### .spec.datacenter.racks[].volumes[].storageos.secretRef
#### Description
secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted.
#### Type
object
| Property | Type | Description |
|------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| name | string | Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: [https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names) |
### .spec.datacenter.racks[].volumes[].vsphereVolume
#### Description
vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine. Deprecated: VsphereVolume is deprecated. All operations for the in-tree vsphereVolume type are redirected to the csi.vsphere.vmware.com CSI driver.
#### Type
object
| Property | Type | Description |
|-------------------|--------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| fsType | string | 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. |
| storagePolicyID | string | storagePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName. |
| storagePolicyName | string | storagePolicyName is the storage Policy Based Management (SPBM) profile name. |
| volumePath | string | volumePath is the path that identifies vSphere volume vmdk |
### .spec.exposeOptions
#### Description
exposeOptions specifies options for exposing ScyllaCluster services. This field is immutable. EXPERIMENTAL. Do not rely on any particular behaviour controlled by this field.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------|--------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [broadcastOptions](#api-scylla-scylladb-com-scyllaclusters-v1-spec-exposeoptions-broadcastoptions) | object | BroadcastOptions defines how ScyllaDB node publishes its IP address to other nodes and clients. |
| [cql](#api-scylla-scylladb-com-scyllaclusters-v1-spec-exposeoptions-cql) | object | cql specifies expose options for CQL SSL backend. EXPERIMENTAL. Do not rely on any particular behaviour controlled by this field. Deprecated: cql is deprecated and will be removed in a future release, along with operator support for exposing CQL over an SNI proxy. |
| [nodeService](#api-scylla-scylladb-com-scyllaclusters-v1-spec-exposeoptions-nodeservice) | object | nodeService controls properties of Service dedicated for each ScyllaCluster node. |
### .spec.exposeOptions.broadcastOptions
#### Description
BroadcastOptions defines how ScyllaDB node publishes its IP address to other nodes and clients.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [clients](#api-scylla-scylladb-com-scyllaclusters-v1-spec-exposeoptions-broadcastoptions-clients) | object | clients specifies options related to the address that is broadcasted for communication with clients. This field controls the broadcast_rpc_address value in ScyllaDB config. |
| [nodes](#api-scylla-scylladb-com-scyllaclusters-v1-spec-exposeoptions-broadcastoptions-nodes) | object | nodes specifies options related to the address that is broadcasted for communication with other nodes. This field controls the broadcast_address value in ScyllaDB config. |
### .spec.exposeOptions.broadcastOptions.clients
#### Description
clients specifies options related to the address that is broadcasted for communication with clients. This field controls the broadcast_rpc_address value in ScyllaDB config.
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------|--------|------------------------------------------------|
| [podIP](#api-scylla-scylladb-com-scyllaclusters-v1-spec-exposeoptions-broadcastoptions-clients-podip) | object | podIP holds options related to Pod IP address. |
| type | string | type of the address that is broadcasted. |
### .spec.exposeOptions.broadcastOptions.clients.podIP
#### Description
podIP holds options related to Pod IP address.
#### Type
object
| Property | Type | Description |
|------------|--------|--------------------------------------------|
| source | string | sourceType specifies source of the Pod IP. |
### .spec.exposeOptions.broadcastOptions.nodes
#### Description
nodes specifies options related to the address that is broadcasted for communication with other nodes. This field controls the broadcast_address value in ScyllaDB config.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------|--------|------------------------------------------------|
| [podIP](#api-scylla-scylladb-com-scyllaclusters-v1-spec-exposeoptions-broadcastoptions-nodes-podip) | object | podIP holds options related to Pod IP address. |
| type | string | type of the address that is broadcasted. |
### .spec.exposeOptions.broadcastOptions.nodes.podIP
#### Description
podIP holds options related to Pod IP address.
#### Type
object
| Property | Type | Description |
|------------|--------|--------------------------------------------|
| source | string | sourceType specifies source of the Pod IP. |
### .spec.exposeOptions.cql
#### Description
cql specifies expose options for CQL SSL backend. EXPERIMENTAL. Do not rely on any particular behaviour controlled by this field. Deprecated: cql is deprecated and will be removed in a future release, along with operator support for exposing CQL over an SNI proxy.
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [ingress](#api-scylla-scylladb-com-scyllaclusters-v1-spec-exposeoptions-cql-ingress) | object | ingress is an Ingress configuration options. EXPERIMENTAL. Do not rely on any particular behaviour controlled by this field. Deprecated: ingress is deprecated and will be removed in a future release, along with operator support for exposing CQL over an SNI proxy. |
### .spec.exposeOptions.cql.ingress
#### Description
ingress is an Ingress configuration options. EXPERIMENTAL. Do not rely on any particular behaviour controlled by this field. Deprecated: ingress is deprecated and will be removed in a future release, along with operator support for exposing CQL over an SNI proxy.
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [annotations](#api-scylla-scylladb-com-scyllaclusters-v1-spec-exposeoptions-cql-ingress-annotations) | object | annotations is a custom key value map that gets merged with managed object annotations. |
| disabled | boolean | disabled controls if Ingress object creation is disabled. Unless disabled, there is an Ingress objects created for every Scylla node. EXPERIMENTAL. Do not rely on any particular behaviour controlled by this field. |
| ingressClassName | string | ingressClassName specifies Ingress class name. EXPERIMENTAL. Do not rely on any particular behaviour controlled by this field. |
| [labels](#api-scylla-scylladb-com-scyllaclusters-v1-spec-exposeoptions-cql-ingress-labels) | object | labels is a custom key value map that gets merged with managed object labels. |
### .spec.exposeOptions.cql.ingress.annotations
#### Description
annotations is a custom key value map that gets merged with managed object annotations.
#### Type
object
### .spec.exposeOptions.cql.ingress.labels
#### Description
labels is a custom key value map that gets merged with managed object labels.
#### Type
object
### .spec.exposeOptions.nodeService
#### Description
nodeService controls properties of Service dedicated for each ScyllaCluster node.
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| allocateLoadBalancerNodePorts | boolean | allocateLoadBalancerNodePorts controls value of service.spec.allocateLoadBalancerNodePorts of each node Service. Check Kubernetes corev1.Service documentation about semantic of this field. |
| [annotations](#api-scylla-scylladb-com-scyllaclusters-v1-spec-exposeoptions-nodeservice-annotations) | object | annotations is a custom key value map that gets merged with managed object annotations. |
| externalTrafficPolicy | string | externalTrafficPolicy controls value of service.spec.externalTrafficPolicy of each node Service. Check Kubernetes corev1.Service documentation about semantic of this field. |
| internalTrafficPolicy | string | internalTrafficPolicy controls value of service.spec.internalTrafficPolicy of each node Service. Check Kubernetes corev1.Service documentation about semantic of this field. |
| [labels](#api-scylla-scylladb-com-scyllaclusters-v1-spec-exposeoptions-nodeservice-labels) | object | labels is a custom key value map that gets merged with managed object labels. |
| loadBalancerClass | string | loadBalancerClass controls value of service.spec.loadBalancerClass of each node Service. Check Kubernetes corev1.Service documentation about semantic of this field. |
| type | string | type is the Kubernetes Service type. |
### .spec.exposeOptions.nodeService.annotations
#### Description
annotations is a custom key value map that gets merged with managed object annotations.
#### Type
object
### .spec.exposeOptions.nodeService.labels
#### Description
labels is a custom key value map that gets merged with managed object labels.
#### Type
object
### .spec.genericUpgrade
#### Description
genericUpgrade allows to configure behavior of generic upgrade logic.
#### Type
object
| Property | Type | Description |
|-----------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| failureStrategy | string | failureStrategy specifies which logic is executed when upgrade failure happens. Currently only Retry is supported. |
| pollInterval | string | pollInterval specifies how often upgrade logic polls on state updates. Increasing this value should lower number of requests sent to apiserver, but it may affect overall time spent during upgrade. DEPRECATED. |
### .spec.imagePullSecrets[]
#### Description
LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.
#### Type
object
| Property | Type | Description |
|------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| name | string | Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: [https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names) |
### .spec.network
#### Description
network holds the networking config.
#### Type
object
| Property | Type | Description |
|----------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| dnsPolicy | string | dnsPolicy defines how a pod’s DNS will be configured. |
| hostNetworking | boolean | hostNetworking determines if scylla uses the host’s network namespace. Setting this option avoids going through Kubernetes SDN and exposes scylla on node’s IP. Deprecated: hostNetworking is deprecated and may be ignored in the future. |
| ipFamilies | array (string) | ipFamilies specifies the IP families to use. Supports: IPv4, IPv6. |
| ipFamilyPolicy | string | ipFamilyPolicy specifies the IP family policy for the cluster. Supports: SingleStack, PreferDualStack, RequireDualStack. |
### .spec.podMetadata
#### Description
podMetadata controls shared metadata for all pods created based on this spec.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------|--------|-----------------------------------------------------------------------------------------|
| [annotations](#api-scylla-scylladb-com-scyllaclusters-v1-spec-podmetadata-annotations) | object | annotations is a custom key value map that gets merged with managed object annotations. |
| [labels](#api-scylla-scylladb-com-scyllaclusters-v1-spec-podmetadata-labels) | object | labels is a custom key value map that gets merged with managed object labels. |
### .spec.podMetadata.annotations
#### Description
annotations is a custom key value map that gets merged with managed object annotations.
#### Type
object
### .spec.podMetadata.labels
#### Description
labels is a custom key value map that gets merged with managed object labels.
#### Type
object
### .spec.readinessGates[]
#### Description
PodReadinessGate contains the reference to a pod condition
#### Type
object
| Property | Type | Description |
|---------------|--------|-------------------------------------------------------------------------------------|
| conditionType | string | ConditionType refers to a condition in the pod’s condition list with matching type. |
### .spec.repairs[]
#### Description
#### Type
object
| Property | Type | Description |
|---------------------|----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| cron | string | cron specifies the task schedule as a cron expression. It supports an extended syntax including @monthly, @weekly, @daily, @midnight, @hourly, @every X[h|m|s]. |
| dc | array (string) | dc is a list of datacenter glob patterns, e.g. ‘dc1’, ‘!otherdc\*’ used to specify the DCs to include or exclude from backup. |
| failFast | boolean | failFast indicates if a repair should be stopped on first error. |
| host | string | host specifies a host to repair. If empty, all hosts are repaired. |
| ignoreDownHosts | boolean | ignoreDownHosts indicates that the nodes in down state should be ignored during repair. |
| intensity | string | intensity indicates how many token ranges (per shard) to repair in a single Scylla repair job. By default this is 1. If you set it to 0 the number of token ranges is adjusted to the maximum supported by node (see max_repair_ranges_in_parallel in Scylla logs). Valid values are 0 and integers >= 1. Higher values will result in increased cluster load and slightly faster repairs. Changing the intensity impacts repair granularity if you need to resume it, the higher the value the more work on resume. For Scylla clusters that *do not support row-level repair*, intensity can be a decimal between (0,1). In that case it specifies percent of shards that can be repaired in parallel on a repair master node. For Scylla clusters that are row-level repair enabled, setting intensity below 1 has the same effect as setting intensity 1. |
| interval | string | interval represents a task schedule interval e.g. 3d2h10m, valid units are d, h, m, s. Deprecated: please use cron instead. |
| keyspace | array (string) | keyspace is a list of keyspace/tables glob patterns, e.g. ‘keyspace,!keyspace.table_prefix_\*’ used to include or exclude keyspaces from repair. |
| name | string | name specifies the name of a task. |
| numRetries | integer | numRetries indicates how many times a scheduled task will be retried before failing. |
| parallel | integer | parallel is the maximum number of Scylla repair jobs that can run at the same time (on different token ranges and replicas). Each node can take part in at most one repair at any given moment. By default the maximum possible parallelism is used. The effective parallelism depends on a keyspace replication factor (RF) and the number of nodes. The formula to calculate it is as follows: number of nodes / RF, ex. for 6 node cluster with RF=3 the maximum parallelism is 2. |
| retryWait | string | retryWait specifies the initial exponential backoff duration for task retries. For instance, if set to 10 minutes, the first retry will be attempted after 10 minutes, the second after 20 minutes, the third after 40 minutes, and so on, up to the number of retries specified in numRetries. If not set, the default values is left to ScyllaDB Manager to decide. |
| smallTableThreshold | string | smallTableThreshold enable small table optimization for tables of size lower than given threshold. Supported units [B, MiB, GiB, TiB]. |
| startDate | string | startDate specifies the task start date expressed in the RFC3339 format or now[+duration], e.g. now+3d2h10m, valid units are d, h, m, s. |
| timezone | string | timezone specifies the timezone of cron field. |
### .status
#### Description
status is the current status of this scylla cluster.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| availableMembers | integer | availableMembers is the number of ScyllaDB members in all racks that are available. |
| [backups](#api-scylla-scylladb-com-scyllaclusters-v1-status-backups) | array (object) | backups reflects status of backup tasks. |
| [conditions](#api-scylla-scylladb-com-scyllaclusters-v1-status-conditions) | array (object) | conditions hold conditions describing ScyllaCluster state. To determine whether a cluster rollout is finished, look for Available=True,Progressing=False,Degraded=False. |
| managerId | string | managerId contains ID under which cluster was registered in Scylla Manager. |
| members | integer | members is the number of ScyllaDB members in all racks. |
| observedGeneration | integer | observedGeneration is the most recent generation observed for this ScyllaCluster. It corresponds to the ScyllaCluster’s generation, which is updated on mutation by the API Server. |
| rackCount | integer | rackCount is the number of ScyllaDB racks in this cluster. |
| [racks](#api-scylla-scylladb-com-scyllaclusters-v1-status-racks) | object | racks reflect status of cluster racks. |
| readyMembers | integer | readyMembers is the number of ScyllaDB members in all racks that are ready. |
| [repairs](#api-scylla-scylladb-com-scyllaclusters-v1-status-repairs) | array (object) | repairs reflects status of repair tasks. |
| [upgrade](#api-scylla-scylladb-com-scyllaclusters-v1-status-upgrade) | object | upgrade reflects state of ongoing upgrade procedure. |
### .status.backups[]
#### Description
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------|
| cron | string | cron reflects the task schedule as a cron expression. |
| dc | array (string) | dc reflects a list of datacenter glob patterns, e.g. ‘dc1,!otherdc\*’ used to specify the DCs to include or exclude from backup. |
| error | string | error holds the task error, if any. |
| id | string | id reflects identification number of the repair task. |
| interval | string | interval reflects a task schedule interval. |
| keyspace | array (string) | keyspace reflects a list of keyspace/tables glob patterns, e.g. ‘keyspace,!keyspace.table_prefix_\*’ used to include or exclude keyspaces from repair. |
| [labels](#api-scylla-scylladb-com-scyllaclusters-v1-status-backups-labels) | object | labels reflects the labels of a task. |
| location | array (string) | location reflects a list of backup locations in the format [:]: ex. s3:my-bucket. |
| name | string | name reflects the name of a task. |
| numRetries | integer | numRetries reflects how many times a scheduled task will be retried before failing. |
| rateLimit | array (string) | rateLimit reflects a list of megabytes (MiB) per second rate limits expressed in the format [:]. |
| retention | integer | retention reflects the number of backups which are to be stored. |
| retryWait | string | retryWait reflects the initial exponential backoff duration for task retries. |
| snapshotParallel | array (string) | snapshotParallel reflects a list of snapshot parallelism limits in the format [:]. |
| startDate | string | startDate reflects the task start date expressed in the RFC3339 format |
| timezone | string | timezone reflects the timezone of cron field. |
| uploadParallel | array (string) | uploadParallel reflects a list of upload parallelism limits in the format [:]. |
### .status.backups[].labels
#### Description
labels reflects the labels of a task.
#### Type
object
### .status.conditions[]
#### Description
Condition contains details for one aspect of the current state of this API Resource.
#### Type
object
| Property | Type | Description |
|--------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| lastTransitionTime | string | lastTransitionTime is the last time the condition transitioned from one status to another. This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. |
| message | string | message is a human readable message indicating details about the transition. This may be an empty string. |
| observedGeneration | integer | observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance. |
| reason | string | reason contains a programmatic identifier indicating the reason for the condition’s last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty. |
| status | string | status of the condition, one of True, False, Unknown. |
| type | string | type of condition in CamelCase or in foo.example.com/CamelCase. |
### .status.racks
#### Description
racks reflect status of cluster racks.
#### Type
object
### .status.repairs[]
#### Description
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------|
| cron | string | cron reflects the task schedule as a cron expression. |
| dc | array (string) | dc reflects a list of datacenter glob patterns, e.g. ‘dc1’, ‘!otherdc\*’ used to specify the DCs to include or exclude from repair. |
| error | string | error holds the task error, if any. |
| failFast | boolean | failFast indicates if a repair should be stopped on first error. |
| host | string | host reflects a host to repair. |
| id | string | id reflects identification number of the repair task. |
| ignoreDownHosts | boolean | ignoreDownHosts reflects whether the nodes in down state are ignored during repair. |
| intensity | string | intensity indicates how many token ranges (per shard) to repair in a single Scylla repair job. By default this is 1. |
| interval | string | interval reflects a task schedule interval. |
| keyspace | array (string) | keyspace reflects a list of keyspace/tables glob patterns, e.g. ‘keyspace,!keyspace.table_prefix_\*’ used to include or exclude keyspaces from repair. |
| [labels](#api-scylla-scylladb-com-scyllaclusters-v1-status-repairs-labels) | object | labels reflects the labels of a task. |
| name | string | name reflects the name of a task. |
| numRetries | integer | numRetries reflects how many times a scheduled task will be retried before failing. |
| parallel | integer | parallel reflects the maximum number of Scylla repair jobs that can run at the same time (on different token ranges and replicas). |
| retryWait | string | retryWait reflects the initial exponential backoff duration for task retries. |
| smallTableThreshold | string | smallTableThreshold reflects whether small table optimization for tables, of size lower than given threshold, are enabled. |
| startDate | string | startDate reflects the task start date expressed in the RFC3339 format |
| timezone | string | timezone reflects the timezone of cron field. |
### .status.repairs[].labels
#### Description
labels reflects the labels of a task.
#### Type
object
### .status.upgrade
#### Description
upgrade reflects state of ongoing upgrade procedure.
#### Type
object
| Property | Type | Description |
|-------------------|--------|--------------------------------------------------------------------------|
| currentNode | string | currentNode node under upgrade. DEPRECATED. |
| currentRack | string | currentRack rack under upgrade. DEPRECATED. |
| dataSnapshotTag | string | dataSnapshotTag is the snapshot tag of data keyspaces. |
| fromVersion | string | fromVersion reflects from which version ScyllaCluster is being upgraded. |
| state | string | state reflects current upgrade state. |
| systemSnapshotTag | string | systemSnapshotTag is the snapshot tag of system keyspaces. |
| toVersion | string | toVersion reflects to which version ScyllaCluster is being upgraded. |
# scylladbclusters.md
# ScyllaDBCluster (scylla.scylladb.com/v1alpha1)
**APIVersion**: scylla.scylladb.com/v1alpha1
**Kind**: ScyllaDBCluster
**PluralName**: scylladbclusters
**SingularName**: scylladbcluster
**Scope**: Namespaced
**ListKind**: ScyllaDBClusterList
**Served**: true
**Storage**: true
## Description
ScyllaDBCluster defines a monitoring instance for ScyllaDB clusters.
## Specification
| Property | Type | Description |
|-------------------------------------------------------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| apiVersion | string | 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](https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources) |
| kind | string | 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](https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds) |
| [metadata](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-metadata) | object | |
| [spec](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec) | object | spec defines the desired state of this ScyllaDBCluster. |
| [status](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-status) | object | status is the current status of this ScyllaDBCluster. |
### .metadata
#### Description
#### Type
object
### .spec
#### Description
spec defines the desired state of this ScyllaDBCluster.
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| clusterName | string | clusterName specifies the name of the ScyllaDB cluster. When joining two DCs, their cluster name must match. If empty, it’s taken from the ‘scylladbcluster.metadata.name’. This field is immutable. |
| [datacenterTemplate](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate) | object | datacenterTemplate provides a template for every datacenter. Every datacenter inherits properties specified in the template, unless the same field is specified on the datacenter level. Depending on the type of field, values are either merged, appended or overwritten. Struct fields are merged following the same principles. Map fields are merged - on collision most specific one wins. Slices are appended. Primitive types are overwritten. |
| [datacenters](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacenters) | array (object) | datacenters specify the datacenters in the cluster. |
| disableAutomaticOrphanedNodeReplacement | boolean | disableAutomaticOrphanedNodeReplacement controls if automatic orphan node replacement should be disabled. |
| [exposeOptions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-exposeoptions) | object | exposeOptions specifies parameters related to exposing ScyllaDBCluster backends. |
| forceRedeploymentReason | string | forceRedeploymentReason can be used to force a rolling restart of all racks in this DC by providing a unique string. |
| [metadata](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-metadata) | object | metadata controls shared metadata for all resources created based on this spec. |
| minReadySeconds | integer | minReadySeconds is the minimum number of seconds for which a newly created ScyllaDB node should be ready for it to be considered available. When used to control load balanced traffic, this can give the load balancer in front of a node enough time to notice that the node is ready and start forwarding traffic in time. Because it all depends on timing, the order is not guaranteed and, if possible, you should use readinessGates instead. If not provided, Operator will determine this value. |
| minTerminationGracePeriodSeconds | integer | minTerminationGracePeriodSeconds specifies minimum duration in seconds to wait before every drained node is terminated. This gives time to potential load balancer in front of a node to notice that node is not ready anymore and stop forwarding new requests. This applies only when node is terminated gracefully. If not provided, Operator will determine this value. EXPERIMENTAL. Do not rely on any particular behaviour controlled by this field. |
| [readinessGates](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-readinessgates) | array (object) | readinessGates specifies custom readiness gates that will be evaluated for every ScyllaDB Pod readiness. It’s projected into every ScyllaDB Pod as its readinessGate. Refer to upstream documentation to learn more about readiness gates. |
| [scyllaDB](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-scylladb) | object | scyllaDB holds a specification of ScyllaDB. |
| [scyllaDBManagerAgent](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-scylladbmanageragent) | object | scyllaDBManagerAgent holds a specification of ScyllaDB Manager Agent. |
### .spec.datacenterTemplate
#### Description
datacenterTemplate provides a template for every datacenter. Every datacenter inherits properties specified in the template, unless the same field is specified on the datacenter level. Depending on the type of field, values are either merged, appended or overwritten. Struct fields are merged following the same principles. Map fields are merged - on collision most specific one wins. Slices are appended. Primitive types are overwritten.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [metadata](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-metadata) | object | metadata controls shared metadata for all pods created based on this datacenter. |
| [placement](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement) | object | placement describes restrictions for the nodes ScyllaDB is scheduled on. |
| [rackTemplate](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate) | object | rackTemplate provides a template for every rack. Every rack inherits properties specified in the template, unless it’s overwritten on the rack level. |
| [racks](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racks) | array (object) | racks specify the racks in the datacenter. |
| [scyllaDB](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-scylladb) | object | scyllaDB defines ScyllaDB properties for this datacenter. These override the settings set on cluster level. |
| [scyllaDBManagerAgent](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-scylladbmanageragent) | object | scyllaDBManagerAgent specifies ScyllaDB Manager Agent properties for this datacenter. These override the settings set on cluster level. |
| [topologyLabelSelector](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-topologylabelselector) | object | topologyLabelSelector specifies a label selector which will be used to target nodes at specified topology constraints. Datacenter topologyLabelSelector is merged with rack topologyLabelSelector and then converted into nodeAffinity targeting nodes having specified topology. |
### .spec.datacenterTemplate.metadata
#### Description
metadata controls shared metadata for all pods created based on this datacenter.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------|--------|----------------------------------------------------------------------------------------------|
| [annotations](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-metadata-annotations) | object | annotations specify a custom key value map that gets merged with managed object annotations. |
| [labels](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-metadata-labels) | object | labels specify a custom key value map that gets merged with managed object labels. |
### .spec.datacenterTemplate.metadata.annotations
#### Description
annotations specify a custom key value map that gets merged with managed object annotations.
#### Type
object
### .spec.datacenterTemplate.metadata.labels
#### Description
labels specify a custom key value map that gets merged with managed object labels.
#### Type
object
### .spec.datacenterTemplate.placement
#### Description
placement describes restrictions for the nodes ScyllaDB is scheduled on.
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [nodeAffinity](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-nodeaffinity) | object | nodeAffinity describes node affinity scheduling rules for the Pod. |
| [podAffinity](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podaffinity) | object | podAffinity describes Pod affinity scheduling rules. |
| [podAntiAffinity](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podantiaffinity) | object | podAntiAffinity describes Pod anti-affinity scheduling rules. |
| [tolerations](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-tolerations) | array (object) | tolerations describe Pod toleration rules. This allows the Pod to tolerate any taint that matches the triple using the matching operator. |
### .spec.datacenterTemplate.placement.nodeAffinity
#### Description
nodeAffinity describes node affinity scheduling rules for the Pod.
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [preferredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-nodeaffinity-preferredduringschedulingignoredduringexecution) | array (object) | 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. |
| [requiredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-nodeaffinity-requiredduringschedulingignoredduringexecution) | object | 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. |
### .spec.datacenterTemplate.placement.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
#### 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).
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|-----------------------------------------------------------------------------------------|
| [preference](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-nodeaffinity-preferredduringschedulingignoredduringexecution-preference) | object | A node selector term, associated with the corresponding weight. |
| weight | integer | Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100. |
### .spec.datacenterTemplate.placement.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference
#### Description
A node selector term, associated with the corresponding weight.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-nodeaffinity-preferredduringschedulingignoredduringexecution-preference-matchexpressions) | array (object) | A list of node selector requirements by node’s labels. |
| [matchFields](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-nodeaffinity-preferredduringschedulingignoredduringexecution-preference-matchfields) | array (object) | A list of node selector requirements by node’s fields. |
### .spec.datacenterTemplate.placement.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchExpressions[]
#### Description
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | The label key that the selector applies to. |
| operator | string | Represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.placement.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchFields[]
#### Description
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | The label key that the selector applies to. |
| operator | string | Represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.placement.nodeAffinity.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.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------------|
| [nodeSelectorTerms](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-nodeaffinity-requiredduringschedulingignoredduringexecution-nodeselectorterms) | array (object) | Required. A list of node selector terms. The terms are ORed. |
### .spec.datacenterTemplate.placement.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[]
#### 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.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-nodeaffinity-requiredduringschedulingignoredduringexecution-nodeselectorterms-matchexpressions) | array (object) | A list of node selector requirements by node’s labels. |
| [matchFields](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-nodeaffinity-requiredduringschedulingignoredduringexecution-nodeselectorterms-matchfields) | array (object) | A list of node selector requirements by node’s fields. |
### .spec.datacenterTemplate.placement.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchExpressions[]
#### Description
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | The label key that the selector applies to. |
| operator | string | Represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.placement.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchFields[]
#### Description
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | The label key that the selector applies to. |
| operator | string | Represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.placement.podAffinity
#### Description
podAffinity describes Pod affinity scheduling rules.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [preferredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podaffinity-preferredduringschedulingignoredduringexecution) | array (object) | 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. |
| [requiredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podaffinity-requiredduringschedulingignoredduringexecution) | array (object) | 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. |
### .spec.datacenterTemplate.placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
#### Description
The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|----------------------------------------------------------------------------------------|
| [podAffinityTerm](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm) | object | Required. A pod affinity term, associated with the corresponding weight. |
| weight | integer | weight associated with matching the corresponding podAffinityTerm, in the range 1-100. |
### .spec.datacenterTemplate.placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
#### Description
Required. A pod affinity term, associated with the corresponding weight.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [labelSelector](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector) | object | A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods. |
| matchLabelKeys | array (string) | MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key in (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn’t set. |
| mismatchLabelKeys | array (string) | MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key notin (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn’t set. |
| [namespaceSelector](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector) | object | 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. |
| namespaces | array (string) | 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”. |
| topologyKey | string | 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. |
### .spec.datacenterTemplate.placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
#### Description
A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector-matchlabels) | object | 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. |
### .spec.datacenterTemplate.placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.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
### .spec.datacenterTemplate.placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.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.
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector-matchlabels) | object | 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. |
### .spec.datacenterTemplate.placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.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
### .spec.datacenterTemplate.placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
#### 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
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [labelSelector](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podaffinity-requiredduringschedulingignoredduringexecution-labelselector) | object | A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods. |
| matchLabelKeys | array (string) | MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key in (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn’t set. |
| mismatchLabelKeys | array (string) | MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key notin (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn’t set. |
| [namespaceSelector](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podaffinity-requiredduringschedulingignoredduringexecution-namespaceselector) | object | 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. |
| namespaces | array (string) | 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”. |
| topologyKey | string | 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. |
### .spec.datacenterTemplate.placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
#### Description
A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podaffinity-requiredduringschedulingignoredduringexecution-labelselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podaffinity-requiredduringschedulingignoredduringexecution-labelselector-matchlabels) | object | 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. |
### .spec.datacenterTemplate.placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.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
### .spec.datacenterTemplate.placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].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.
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podaffinity-requiredduringschedulingignoredduringexecution-namespaceselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podaffinity-requiredduringschedulingignoredduringexecution-namespaceselector-matchlabels) | object | 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. |
### .spec.datacenterTemplate.placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.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
### .spec.datacenterTemplate.placement.podAntiAffinity
#### Description
podAntiAffinity describes Pod anti-affinity scheduling rules.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [preferredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podantiaffinity-preferredduringschedulingignoredduringexecution) | array (object) | 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 subtracting “weight” from the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. |
| [requiredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podantiaffinity-requiredduringschedulingignoredduringexecution) | array (object) | 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. |
### .spec.datacenterTemplate.placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
#### Description
The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|----------------------------------------------------------------------------------------|
| [podAffinityTerm](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm) | object | Required. A pod affinity term, associated with the corresponding weight. |
| weight | integer | weight associated with matching the corresponding podAffinityTerm, in the range 1-100. |
### .spec.datacenterTemplate.placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
#### Description
Required. A pod affinity term, associated with the corresponding weight.
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [labelSelector](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector) | object | A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods. |
| matchLabelKeys | array (string) | MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key in (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn’t set. |
| mismatchLabelKeys | array (string) | MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key notin (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn’t set. |
| [namespaceSelector](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector) | object | 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. |
| namespaces | array (string) | 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”. |
| topologyKey | string | 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. |
### .spec.datacenterTemplate.placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
#### Description
A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods.
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector-matchlabels) | object | 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. |
### .spec.datacenterTemplate.placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.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
### .spec.datacenterTemplate.placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.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.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector-matchlabels) | object | 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. |
### .spec.datacenterTemplate.placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.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
### .spec.datacenterTemplate.placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
#### 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
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [labelSelector](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podantiaffinity-requiredduringschedulingignoredduringexecution-labelselector) | object | A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods. |
| matchLabelKeys | array (string) | MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key in (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn’t set. |
| mismatchLabelKeys | array (string) | MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key notin (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn’t set. |
| [namespaceSelector](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podantiaffinity-requiredduringschedulingignoredduringexecution-namespaceselector) | object | 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. |
| namespaces | array (string) | 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”. |
| topologyKey | string | 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. |
### .spec.datacenterTemplate.placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
#### Description
A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods.
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podantiaffinity-requiredduringschedulingignoredduringexecution-labelselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podantiaffinity-requiredduringschedulingignoredduringexecution-labelselector-matchlabels) | object | 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. |
### .spec.datacenterTemplate.placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.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
### .spec.datacenterTemplate.placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].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.
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podantiaffinity-requiredduringschedulingignoredduringexecution-namespaceselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-placement-podantiaffinity-requiredduringschedulingignoredduringexecution-namespaceselector-matchlabels) | object | 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. |
### .spec.datacenterTemplate.placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.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
### .spec.datacenterTemplate.placement.tolerations[]
#### Description
The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .
#### Type
object
| Property | Type | Description |
|-------------------|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| effect | string | Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute. |
| key | string | 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. |
| operator | string | Operator represents a key’s relationship to the value. Valid operators are Exists, Equal, Lt, and Gt. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. Lt and Gt perform numeric comparisons (requires feature gate TaintTolerationComparisonOperators). |
| tolerationSeconds | integer | 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. |
| value | string | Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string. |
### .spec.datacenterTemplate.rackTemplate
#### Description
rackTemplate provides a template for every rack. Every rack inherits properties specified in the template, unless it’s overwritten on the rack level.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [exposeOptions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-exposeoptions) | object | exposeOptions specifies rack-specific parameters related to exposing ScyllaDBDatacenter backends. |
| nodes | integer | nodes specify the desired number of nodes in rack. |
| [placement](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement) | object | placement describes restrictions for the nodes ScyllaDB is scheduled on. |
| [scyllaDB](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb) | object | scyllaDB specifies ScyllaDB properties for this rack. These override the settings set on Datacenter level. |
| [scyllaDBManagerAgent](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladbmanageragent) | object | scyllaDBManagerAgent specifies ScyllaDB Manager Agent properties for this rack. These override the settings set on Datacenter level. |
| [topologyLabelSelector](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-topologylabelselector) | object | topologyLabelSelector specifies a label selector which will be used to target nodes at specified topology constraints. Datacenter topologyLabelSelector is merged with rack topologyLabelSelector and then converted into nodeAffinity targeting nodes having specified topology. |
### .spec.datacenterTemplate.rackTemplate.exposeOptions
#### Description
exposeOptions specifies rack-specific parameters related to exposing ScyllaDBDatacenter backends.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------|--------|------------------------------------------------------------------------------------------------------|
| [nodeService](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-exposeoptions-nodeservice) | object | nodeService controls properties of Service dedicated for each ScyllaDBDatacenter node in given rack. |
### .spec.datacenterTemplate.rackTemplate.exposeOptions.nodeService
#### Description
nodeService controls properties of Service dedicated for each ScyllaDBDatacenter node in given rack.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------------|--------|----------------------------------------------------------------------------------------------|
| [annotations](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-exposeoptions-nodeservice-annotations) | object | annotations specify a custom key value map that gets merged with managed object annotations. |
| [labels](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-exposeoptions-nodeservice-labels) | object | labels specify a custom key value map that gets merged with managed object labels. |
### .spec.datacenterTemplate.rackTemplate.exposeOptions.nodeService.annotations
#### Description
annotations specify a custom key value map that gets merged with managed object annotations.
#### Type
object
### .spec.datacenterTemplate.rackTemplate.exposeOptions.nodeService.labels
#### Description
labels specify a custom key value map that gets merged with managed object labels.
#### Type
object
### .spec.datacenterTemplate.rackTemplate.placement
#### Description
placement describes restrictions for the nodes ScyllaDB is scheduled on.
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [nodeAffinity](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-nodeaffinity) | object | nodeAffinity describes node affinity scheduling rules for the Pod. |
| [podAffinity](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podaffinity) | object | podAffinity describes Pod affinity scheduling rules. |
| [podAntiAffinity](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podantiaffinity) | object | podAntiAffinity describes Pod anti-affinity scheduling rules. |
| [tolerations](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-tolerations) | array (object) | tolerations describe Pod toleration rules. This allows the Pod to tolerate any taint that matches the triple using the matching operator. |
### .spec.datacenterTemplate.rackTemplate.placement.nodeAffinity
#### Description
nodeAffinity describes node affinity scheduling rules for the Pod.
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [preferredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-nodeaffinity-preferredduringschedulingignoredduringexecution) | array (object) | 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. |
| [requiredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-nodeaffinity-requiredduringschedulingignoredduringexecution) | object | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
#### 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).
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|-----------------------------------------------------------------------------------------|
| [preference](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-nodeaffinity-preferredduringschedulingignoredduringexecution-preference) | object | A node selector term, associated with the corresponding weight. |
| weight | integer | Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100. |
### .spec.datacenterTemplate.rackTemplate.placement.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference
#### Description
A node selector term, associated with the corresponding weight.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-nodeaffinity-preferredduringschedulingignoredduringexecution-preference-matchexpressions) | array (object) | A list of node selector requirements by node’s labels. |
| [matchFields](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-nodeaffinity-preferredduringschedulingignoredduringexecution-preference-matchfields) | array (object) | A list of node selector requirements by node’s fields. |
### .spec.datacenterTemplate.rackTemplate.placement.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchExpressions[]
#### Description
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | The label key that the selector applies to. |
| operator | string | Represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchFields[]
#### Description
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | The label key that the selector applies to. |
| operator | string | Represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.nodeAffinity.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.
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------------|
| [nodeSelectorTerms](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-nodeaffinity-requiredduringschedulingignoredduringexecution-nodeselectorterms) | array (object) | Required. A list of node selector terms. The terms are ORed. |
### .spec.datacenterTemplate.rackTemplate.placement.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[]
#### 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.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-nodeaffinity-requiredduringschedulingignoredduringexecution-nodeselectorterms-matchexpressions) | array (object) | A list of node selector requirements by node’s labels. |
| [matchFields](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-nodeaffinity-requiredduringschedulingignoredduringexecution-nodeselectorterms-matchfields) | array (object) | A list of node selector requirements by node’s fields. |
### .spec.datacenterTemplate.rackTemplate.placement.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchExpressions[]
#### Description
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | The label key that the selector applies to. |
| operator | string | Represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchFields[]
#### Description
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | The label key that the selector applies to. |
| operator | string | Represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAffinity
#### Description
podAffinity describes Pod affinity scheduling rules.
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [preferredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podaffinity-preferredduringschedulingignoredduringexecution) | array (object) | 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. |
| [requiredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podaffinity-requiredduringschedulingignoredduringexecution) | array (object) | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
#### Description
The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|----------------------------------------------------------------------------------------|
| [podAffinityTerm](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm) | object | Required. A pod affinity term, associated with the corresponding weight. |
| weight | integer | weight associated with matching the corresponding podAffinityTerm, in the range 1-100. |
### .spec.datacenterTemplate.rackTemplate.placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
#### Description
Required. A pod affinity term, associated with the corresponding weight.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [labelSelector](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector) | object | A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods. |
| matchLabelKeys | array (string) | MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key in (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn’t set. |
| mismatchLabelKeys | array (string) | MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key notin (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn’t set. |
| [namespaceSelector](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector) | object | 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. |
| namespaces | array (string) | 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”. |
| topologyKey | string | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
#### Description
A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector-matchlabels) | object | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.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
### .spec.datacenterTemplate.rackTemplate.placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.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.
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector-matchlabels) | object | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.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
### .spec.datacenterTemplate.rackTemplate.placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
#### 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
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [labelSelector](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podaffinity-requiredduringschedulingignoredduringexecution-labelselector) | object | A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods. |
| matchLabelKeys | array (string) | MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key in (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn’t set. |
| mismatchLabelKeys | array (string) | MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key notin (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn’t set. |
| [namespaceSelector](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podaffinity-requiredduringschedulingignoredduringexecution-namespaceselector) | object | 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. |
| namespaces | array (string) | 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”. |
| topologyKey | string | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
#### Description
A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podaffinity-requiredduringschedulingignoredduringexecution-labelselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podaffinity-requiredduringschedulingignoredduringexecution-labelselector-matchlabels) | object | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.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
### .spec.datacenterTemplate.rackTemplate.placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].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.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podaffinity-requiredduringschedulingignoredduringexecution-namespaceselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podaffinity-requiredduringschedulingignoredduringexecution-namespaceselector-matchlabels) | object | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.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
### .spec.datacenterTemplate.rackTemplate.placement.podAntiAffinity
#### Description
podAntiAffinity describes Pod anti-affinity scheduling rules.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [preferredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podantiaffinity-preferredduringschedulingignoredduringexecution) | array (object) | 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 subtracting “weight” from the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. |
| [requiredDuringSchedulingIgnoredDuringExecution](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podantiaffinity-requiredduringschedulingignoredduringexecution) | array (object) | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
#### Description
The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|----------------------------------------------------------------------------------------|
| [podAffinityTerm](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm) | object | Required. A pod affinity term, associated with the corresponding weight. |
| weight | integer | weight associated with matching the corresponding podAffinityTerm, in the range 1-100. |
### .spec.datacenterTemplate.rackTemplate.placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
#### Description
Required. A pod affinity term, associated with the corresponding weight.
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [labelSelector](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector) | object | A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods. |
| matchLabelKeys | array (string) | MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key in (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn’t set. |
| mismatchLabelKeys | array (string) | MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key notin (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn’t set. |
| [namespaceSelector](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector) | object | 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. |
| namespaces | array (string) | 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”. |
| topologyKey | string | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
#### Description
A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods.
#### Type
object
| Property | Type | Description |
|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-labelselector-matchlabels) | object | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.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
### .spec.datacenterTemplate.rackTemplate.placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.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.
#### Type
object
| Property | Type | Description |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podantiaffinity-preferredduringschedulingignoredduringexecution-podaffinityterm-namespaceselector-matchlabels) | object | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.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
### .spec.datacenterTemplate.rackTemplate.placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
#### 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
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [labelSelector](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podantiaffinity-requiredduringschedulingignoredduringexecution-labelselector) | object | A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods. |
| matchLabelKeys | array (string) | MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key in (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn’t set. |
| mismatchLabelKeys | array (string) | MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with labelSelector as key notin (value) to select the group of existing pods which pods will be taken into consideration for the incoming pod’s pod (anti) affinity. Keys that don’t exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn’t set. |
| [namespaceSelector](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podantiaffinity-requiredduringschedulingignoredduringexecution-namespaceselector) | object | 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. |
| namespaces | array (string) | 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”. |
| topologyKey | string | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
#### Description
A label query over a set of resources, in this case pods. If it’s null, this PodAffinityTerm matches with no Pods.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podantiaffinity-requiredduringschedulingignoredduringexecution-labelselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podantiaffinity-requiredduringschedulingignoredduringexecution-labelselector-matchlabels) | object | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.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
### .spec.datacenterTemplate.rackTemplate.placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].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.
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [matchExpressions](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podantiaffinity-requiredduringschedulingignoredduringexecution-namespaceselector-matchexpressions) | array (object) | matchExpressions is a list of label selector requirements. The requirements are ANDed. |
| [matchLabels](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-placement-podantiaffinity-requiredduringschedulingignoredduringexecution-namespaceselector-matchlabels) | object | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
#### Description
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
#### Type
object
| Property | Type | Description |
|------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the label key that the selector applies to. |
| operator | string | operator represents a key’s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. |
| values | array (string) | 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. |
### .spec.datacenterTemplate.rackTemplate.placement.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.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
### .spec.datacenterTemplate.rackTemplate.placement.tolerations[]
#### Description
The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .
#### Type
object
| Property | Type | Description |
|-------------------|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| effect | string | Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute. |
| key | string | 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. |
| operator | string | Operator represents a key’s relationship to the value. Valid operators are Exists, Equal, Lt, and Gt. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. Lt and Gt perform numeric comparisons (requires feature gate TaintTolerationComparisonOperators). |
| tolerationSeconds | integer | 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. |
| value | string | Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string. |
### .spec.datacenterTemplate.rackTemplate.scyllaDB
#### Description
scyllaDB specifies ScyllaDB properties for this rack. These override the settings set on Datacenter level.
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------------------------------------------------------------------------------|
| customConfigMapRef | string | customConfigMapRef specifies a reference to custom ScyllaDB configuration stored as ConfigMap. Overrides upper level settings. |
| [resources](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-resources) | object | resources specify requirements for the ScyllaDB container |
| [storage](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-storage) | object | storage specifies requirements for the containers |
| [volumeMounts](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumemounts) | array (object) | volumeMounts specify a list of volume mounts appended to ScyllaDB container. |
| [volumes](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes) | array (object) | volumes specify a list of volumes appended to ScyllaDB Pod. |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.resources
#### Description
resources specify requirements for the ScyllaDB container
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------|----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [claims](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-resources-claims) | array (object) | Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. This field depends on the DynamicResourceAllocation feature gate. This field is immutable. It can only be set for containers. |
| [limits](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-resources-limits) | object | Limits describes the maximum amount of compute resources allowed. More info: [https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) |
| [requests](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-resources-requests) | object | 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. Requests cannot exceed Limits. More info: [https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.resources.claims[]
#### Description
ResourceClaim references one entry in PodSpec.ResourceClaims.
#### Type
object
| Property | Type | Description |
|------------|--------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| name | string | Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container. |
| request | string | Request is the name chosen for a request in the referenced claim. If empty, everything from the claim is made available, otherwise only the result of this request. |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.resources.limits
#### Description
Limits describes the maximum amount of compute resources allowed. More info: [https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/)
#### Type
object
### .spec.datacenterTemplate.rackTemplate.scyllaDB.resources.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. Requests cannot exceed Limits. More info: [https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/)
#### Type
object
### .spec.datacenterTemplate.rackTemplate.scyllaDB.storage
#### Description
storage specifies requirements for the containers
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| capacity | string | capacity describes the requested size of each persistent volume. |
| [metadata](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-storage-metadata) | object | metadata controls shared metadata for the volume claim for this rack. At this point, the values are applied only for the initial claim and are not reconciled during its lifetime. Note that this may get fixed in the future and this behaviour shouldn’t be relied on in any way. |
| storageClassName | string | storageClassName specifies the name of a storageClass to request. |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.storage.metadata
#### Description
metadata controls shared metadata for the volume claim for this rack. At this point, the values are applied only for the initial claim and are not reconciled during its lifetime. Note that this may get fixed in the future and this behaviour shouldn’t be relied on in any way.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------------|--------|----------------------------------------------------------------------------------------------|
| [annotations](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-storage-metadata-annotations) | object | annotations specify a custom key value map that gets merged with managed object annotations. |
| [labels](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-storage-metadata-labels) | object | labels specify a custom key value map that gets merged with managed object labels. |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.storage.metadata.annotations
#### Description
annotations specify a custom key value map that gets merged with managed object annotations.
#### Type
object
### .spec.datacenterTemplate.rackTemplate.scyllaDB.storage.metadata.labels
#### Description
labels specify a custom key value map that gets merged with managed object labels.
#### Type
object
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumeMounts[]
#### Description
VolumeMount describes a mounting of a Volume within a container.
#### Type
object
| Property | Type | Description |
|-------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| mountPath | string | Path within the container at which the volume should be mounted. Must not contain ‘:’. |
| mountPropagation | string | 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. When RecursiveReadOnly is set to IfPossible or to Enabled, MountPropagation must be None or unspecified (which defaults to None). |
| name | string | This must match the Name of a Volume. |
| readOnly | boolean | Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false. |
| recursiveReadOnly | string | RecursiveReadOnly specifies whether read-only mounts should be handled recursively. If ReadOnly is false, this field has no meaning and must be unspecified. If ReadOnly is true, and this field is set to Disabled, the mount is not made recursively read-only. If this field is set to IfPossible, the mount is made recursively read-only, if it is supported by the container runtime. If this field is set to Enabled, the mount is made recursively read-only if it is supported by the container runtime, otherwise the pod will not be started and an error will be generated to indicate the reason. If this field is set to IfPossible or Enabled, MountPropagation must be set to None (or be unspecified, which defaults to None). If this field is not specified, it is treated as an equivalent of Disabled. |
| subPath | string | Path within the volume from which the container’s volume should be mounted. Defaults to “” (volume’s root). |
| subPathExpr | string | 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. |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumes[]
#### Description
Volume represents a named volume in a pod that may be accessed by any container in the pod.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------------------------------|--------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [awsElasticBlockStore](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-awselasticblockstore) | object | awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet’s host machine and then exposed to the pod. Deprecated: AWSElasticBlockStore is deprecated. All operations for the in-tree awsElasticBlockStore type are redirected to the ebs.csi.aws.com CSI driver. More info: [https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore](https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore) |
| [azureDisk](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-azuredisk) | object | azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod. Deprecated: AzureDisk is deprecated. All operations for the in-tree azureDisk type are redirected to the disk.csi.azure.com CSI driver. |
| [azureFile](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-azurefile) | object | azureFile represents an Azure File Service mount on the host and bind mount to the pod. Deprecated: AzureFile is deprecated. All operations for the in-tree azureFile type are redirected to the file.csi.azure.com CSI driver. |
| [cephfs](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-cephfs) | object | cephFS represents a Ceph FS mount on the host that shares a pod’s lifetime. Deprecated: CephFS is deprecated and the in-tree cephfs type is no longer supported. |
| [cinder](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-cinder) | object | cinder represents a cinder volume attached and mounted on kubelets host machine. Deprecated: Cinder is deprecated. All operations for the in-tree cinder type are redirected to the cinder.csi.openstack.org CSI driver. More info: [https://examples.k8s.io/mysql-cinder-pd/README.md](https://examples.k8s.io/mysql-cinder-pd/README.md) |
| [configMap](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-configmap) | object | configMap represents a configMap that should populate this volume |
| [csi](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-csi) | object | csi (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers. |
| [downwardAPI](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-downwardapi) | object | downwardAPI represents downward API about the pod that should populate this volume |
| [emptyDir](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-emptydir) | object | emptyDir represents a temporary directory that shares a pod’s lifetime. More info: [https://kubernetes.io/docs/concepts/storage/volumes#emptydir](https://kubernetes.io/docs/concepts/storage/volumes#emptydir) |
| [ephemeral](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-ephemeral) | object | 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. Use this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity tracking are needed, c) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through a PersistentVolumeClaim (see EphemeralVolumeSource for more information on the connection between this volume type and PersistentVolumeClaim). Use PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod. Use 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. A pod can use both types of ephemeral volumes and persistent volumes at the same time. |
| [fc](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-fc) | object | fc represents a Fibre Channel resource that is attached to a kubelet’s host machine and then exposed to the pod. |
| [flexVolume](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-flexvolume) | object | flexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin. Deprecated: FlexVolume is deprecated. Consider using a CSIDriver instead. |
| [flocker](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-flocker) | object | flocker represents a Flocker volume attached to a kubelet’s host machine. This depends on the Flocker control service being running. Deprecated: Flocker is deprecated and the in-tree flocker type is no longer supported. |
| [gcePersistentDisk](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-gcepersistentdisk) | object | gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet’s host machine and then exposed to the pod. Deprecated: GCEPersistentDisk is deprecated. All operations for the in-tree gcePersistentDisk type are redirected to the pd.csi.storage.gke.io CSI driver. More info: [https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk](https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk) |
| [gitRepo](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-gitrepo) | object | 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. |
| [glusterfs](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-glusterfs) | object | glusterfs represents a Glusterfs mount on the host that shares a pod’s lifetime. Deprecated: Glusterfs is deprecated and the in-tree glusterfs type is no longer supported. |
| [hostPath](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-hostpath) | object | 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](https://kubernetes.io/docs/concepts/storage/volumes#hostpath) |
| [image](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-image) | object | image represents an OCI object (a container image or artifact) pulled and mounted on the kubelet’s host machine. The volume is resolved at pod startup depending on which PullPolicy value is provided: - Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. - Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn’t present. - IfNotPresent: the kubelet pulls if the reference isn’t already present on disk. Container creation will fail if the reference isn’t present and the pull fails. The volume gets re-resolved if the pod gets deleted and recreated, which means that new remote content will become available on pod recreation. A failure to resolve or pull the image during pod startup will block containers from starting and may add significant latency. Failures will be retried using normal volume backoff and will be reported on the pod reason and message. The types of objects that may be mounted by this volume are defined by the container runtime implementation on a host machine and at minimum must include all valid types supported by the container image field. The OCI object gets mounted in a single directory (spec.containers[\*].volumeMounts.mountPath) by merging the manifest layers in the same way as for container images. The volume will be mounted read-only (ro). Sub path mounts for containers are not supported (spec.containers[\*].volumeMounts.subpath) before 1.33. The field spec.securityContext.fsGroupChangePolicy has no effect on this volume type. |
| [iscsi](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-iscsi) | object | iscsi represents an ISCSI 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/#iscsi](https://kubernetes.io/docs/concepts/storage/volumes/#iscsi) |
| name | string | 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](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names) |
| [nfs](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-nfs) | object | nfs represents an NFS mount on the host that shares a pod’s lifetime More info: [https://kubernetes.io/docs/concepts/storage/volumes#nfs](https://kubernetes.io/docs/concepts/storage/volumes#nfs) |
| [persistentVolumeClaim](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-persistentvolumeclaim) | object | persistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: [https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims](https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims) |
| [photonPersistentDisk](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-photonpersistentdisk) | object | photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine. Deprecated: PhotonPersistentDisk is deprecated and the in-tree photonPersistentDisk type is no longer supported. |
| [portworxVolume](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-portworxvolume) | object | portworxVolume represents a portworx volume attached and mounted on kubelets host machine. Deprecated: PortworxVolume is deprecated. All operations for the in-tree portworxVolume type are redirected to the pxd.portworx.com CSI driver. |
| [projected](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-projected) | object | projected items for all in one resources secrets, configmaps, and downward API |
| [quobyte](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-quobyte) | object | quobyte represents a Quobyte mount on the host that shares a pod’s lifetime. Deprecated: Quobyte is deprecated and the in-tree quobyte type is no longer supported. |
| [rbd](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-rbd) | object | rbd represents a Rados Block Device mount on the host that shares a pod’s lifetime. Deprecated: RBD is deprecated and the in-tree rbd type is no longer supported. |
| [scaleIO](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-scaleio) | object | scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes. Deprecated: ScaleIO is deprecated and the in-tree scaleIO type is no longer supported. |
| [secret](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-secret) | object | secret represents a secret that should populate this volume. More info: [https://kubernetes.io/docs/concepts/storage/volumes#secret](https://kubernetes.io/docs/concepts/storage/volumes#secret) |
| [storageos](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-storageos) | object | storageOS represents a StorageOS volume attached and mounted on Kubernetes nodes. Deprecated: StorageOS is deprecated and the in-tree storageos type is no longer supported. |
| [vsphereVolume](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-vspherevolume) | object | vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine. Deprecated: VsphereVolume is deprecated. All operations for the in-tree vsphereVolume type are redirected to the csi.vsphere.vmware.com CSI driver. |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumes[].awsElasticBlockStore
#### Description
awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet’s host machine and then exposed to the pod. Deprecated: AWSElasticBlockStore is deprecated. All operations for the in-tree awsElasticBlockStore type are redirected to the ebs.csi.aws.com CSI driver. More info: [https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore](https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore)
#### Type
object
| Property | Type | Description |
|------------|---------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| fsType | string | 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](https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore) |
| partition | integer | 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). |
| readOnly | boolean | readOnly value true will force the readOnly setting in VolumeMounts. More info: [https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore](https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore) |
| volumeID | string | volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: [https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore](https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore) |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumes[].azureDisk
#### Description
azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod. Deprecated: AzureDisk is deprecated. All operations for the in-tree azureDisk type are redirected to the disk.csi.azure.com CSI driver.
#### Type
object
| Property | Type | Description |
|-------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| cachingMode | string | cachingMode is the Host Caching mode: None, Read Only, Read Write. |
| diskName | string | diskName is the Name of the data disk in the blob storage |
| diskURI | string | diskURI is the URI of data disk in the blob storage |
| fsType | string | 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. |
| kind | string | 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 |
| readOnly | boolean | readOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumes[].azureFile
#### Description
azureFile represents an Azure File Service mount on the host and bind mount to the pod. Deprecated: AzureFile is deprecated. All operations for the in-tree azureFile type are redirected to the file.csi.azure.com CSI driver.
#### Type
object
| Property | Type | Description |
|------------|---------|---------------------------------------------------------------------------------------------------------|
| readOnly | boolean | readOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. |
| secretName | string | secretName is the name of secret that contains Azure Storage Account Name and Key |
| shareName | string | shareName is the azure share Name |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumes[].cephfs
#### Description
cephFS represents a Ceph FS mount on the host that shares a pod’s lifetime. Deprecated: CephFS is deprecated and the in-tree cephfs type is no longer supported.
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------|----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| monitors | array (string) | monitors is Required: Monitors is a collection of Ceph monitors More info: [https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it](https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it) |
| path | string | path is Optional: Used as the mounted root, rather than the full Ceph tree, default is / |
| readOnly | boolean | 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](https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it) |
| secretFile | string | 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](https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it) |
| [secretRef](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-cephfs-secretref) | object | 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](https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it) |
| user | string | 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](https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it) |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumes[].cephfs.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](https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it)
#### Type
object
| Property | Type | Description |
|------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| name | string | Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: [https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names) |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumes[].cinder
#### Description
cinder represents a cinder volume attached and mounted on kubelets host machine. Deprecated: Cinder is deprecated. All operations for the in-tree cinder type are redirected to the cinder.csi.openstack.org CSI driver. More info: [https://examples.k8s.io/mysql-cinder-pd/README.md](https://examples.k8s.io/mysql-cinder-pd/README.md)
#### Type
object
| Property | Type | Description |
|----------------------------------------------------------------------------------------------------------------------------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| fsType | string | 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](https://examples.k8s.io/mysql-cinder-pd/README.md) |
| readOnly | boolean | 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](https://examples.k8s.io/mysql-cinder-pd/README.md) |
| [secretRef](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-cinder-secretref) | object | secretRef is optional: points to a secret object containing parameters used to connect to OpenStack. |
| volumeID | string | volumeID used to identify the volume in cinder. More info: [https://examples.k8s.io/mysql-cinder-pd/README.md](https://examples.k8s.io/mysql-cinder-pd/README.md) |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumes[].cinder.secretRef
#### Description
secretRef is optional: points to a secret object containing parameters used to connect to OpenStack.
#### Type
object
| Property | Type | Description |
|------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| name | string | Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: [https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names) |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumes[].configMap
#### Description
configMap represents a configMap that should populate this volume
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------------|----------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| defaultMode | integer | 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. |
| [items](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-configmap-items) | array (object) | 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 ‘..’. |
| name | string | Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: [https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names) |
| optional | boolean | optional specify whether the ConfigMap or its keys must be defined |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumes[].configMap.items[]
#### Description
Maps a string key to a path within a volume.
#### Type
object
| Property | Type | Description |
|------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| key | string | key is the key to project. |
| mode | integer | 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. |
| path | string | 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 ‘..’. |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumes[].csi
#### Description
csi (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers.
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| driver | string | 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. |
| fsType | string | 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. |
| [nodePublishSecretRef](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-csi-nodepublishsecretref) | object | 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. |
| readOnly | boolean | readOnly specifies a read-only configuration for the volume. Defaults to false (read/write). |
| [volumeAttributes](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-csi-volumeattributes) | object | volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver’s documentation for supported values. |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumes[].csi.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.
#### Type
object
| Property | Type | Description |
|------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| name | string | Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: [https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names) |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumes[].csi.volumeAttributes
#### Description
volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver’s documentation for supported values.
#### Type
object
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumes[].downwardAPI
#### Description
downwardAPI represents downward API about the pod that should populate this volume
#### Type
object
| Property | Type | Description |
|-------------------------------------------------------------------------------------------------------------------------------------|----------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| defaultMode | integer | 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. |
| [items](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-downwardapi-items) | array (object) | Items is a list of downward API volume file |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumes[].downwardAPI.items[]
#### Description
DownwardAPIVolumeFile represents information to create the file containing the pod field
#### Type
object
| Property | Type | Description |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [fieldRef](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-downwardapi-items-fieldref) | object | Required: Selects a field of the pod: only annotations, labels, name, namespace and uid are supported. |
| mode | integer | 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. |
| path | string | 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 ‘..’ |
| [resourceFieldRef](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-downwardapi-items-resourcefieldref) | object | Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported. |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumes[].downwardAPI.items[].fieldRef
#### Description
Required: Selects a field of the pod: only annotations, labels, name, namespace and uid are supported.
#### Type
object
| Property | Type | Description |
|------------|--------|-------------------------------------------------------------------------------|
| apiVersion | string | Version of the schema the FieldPath is written in terms of, defaults to “v1”. |
| fieldPath | string | Path of the field to select in the specified API version. |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumes[].downwardAPI.items[].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.
#### Type
object
| Property | Type | Description |
|---------------|--------|-----------------------------------------------------------------------|
| containerName | string | Container name: required for volumes, optional for env vars |
| divisor | | Specifies the output format of the exposed resources, defaults to “1” |
| resource | string | Required: resource to select |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumes[].emptyDir
#### Description
emptyDir represents a temporary directory that shares a pod’s lifetime. More info: [https://kubernetes.io/docs/concepts/storage/volumes#emptydir](https://kubernetes.io/docs/concepts/storage/volumes#emptydir)
#### Type
object
| Property | Type | Description |
|------------|--------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| medium | string | 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](https://kubernetes.io/docs/concepts/storage/volumes#emptydir) |
| sizeLimit | | 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: [https://kubernetes.io/docs/concepts/storage/volumes#emptydir](https://kubernetes.io/docs/concepts/storage/volumes#emptydir) |
### .spec.datacenterTemplate.rackTemplate.scyllaDB.volumes[].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. Use this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity tracking are needed, c) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through a PersistentVolumeClaim (see EphemeralVolumeSource for more information on the connection between this volume type and PersistentVolumeClaim). Use PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod. Use 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. A pod can use both types of ephemeral volumes and persistent volumes at the same time.
#### Type
object
| Property | Type | Description |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------|--------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [volumeClaimTemplate](#api-scylla-scylladb-com-scylladbclusters-v1alpha1-spec-datacentertemplate-racktemplate-scylladb-volumes-ephemeral-volumeclaimtemplate) | object | 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). An 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. This field is read-only and no changes will be made by Kubernetes to the PVC after it has been created. Required, must not be nil. |