---
type: Deployment Guide
title: '[Deprecated] Configure a custom values file for ScalarDB GraphQL'
description: ScalarDB GraphQL Server is now deprecated. Please use ScalarDB Cluster instead.
resource: https://scalardl.scalar-labs.com/docs/3.10/helm-charts/configure-custom-values-scalardb-graphql/
tags:
- scalardl
- v3.10
- phase:operate
- edition:enterprise-standard
- edition:enterprise-premium
- unmaintained
status: deprecated
product: scalardl
product_title: ScalarDL
version: '3.10'
patch_version: 3.10.5
doc_id: helm-charts/configure-custom-values-scalardb-graphql
lifecycle_phase: operate
editions:
- Enterprise Standard
- Enterprise Premium
generated:
  by: process:okf-build/1.0.0
  at: '2026-08-04T23:51:03Z'
sources:
- id: docs-scalardl
  resource: https://github.com/scalar-labs/docs-scalardl/blob/c1dbc91f4c36ec4ce63e7181302c89b7b6669e62/versioned_docs/version-3.10/helm-charts/configure-custom-values-scalardb-graphql.mdx
  title: ScalarDL documentation source (MDX)
  author: process:scalar-labs/docs-scalardl
  last_modified: '2026-08-04T15:05:14Z'
---

# [Deprecated] Configure a custom values file for ScalarDB GraphQL

:::note

ScalarDB GraphQL Server is now deprecated. Please use [ScalarDB Cluster](./configure-custom-values-scalardb-cluster.md) instead.

:::

This document explains how to create your custom values file for the ScalarDB GraphQL chart. If you want to know the details of the parameters, please refer to the [README](https://github.com/scalar-labs/helm-charts/blob/main/charts/scalardb-graphql/README.md) of the ScalarDB GraphQL chart.

## Required configurations

### Ingress configuration

You must set `ingress` to listen the client requests. When you deploy multiple GraphQL servers, session affinity is required to handle transactions properly. This is because GraphQL servers keep the transactions in memory, so GraphQL queries that use continued transactions must be routed to the same server that started the transaction.

For example, if you use NGINX Ingress Controller, you can set ingress configurations as follows.

```yaml
ingress:
  enabled: true
  className: nginx
  annotations:
    nginx.ingress.kubernetes.io/session-cookie-path: /
    nginx.ingress.kubernetes.io/affinity: cookie
    nginx.ingress.kubernetes.io/session-cookie-name: INGRESSCOOKIE
    nginx.ingress.kubernetes.io/session-cookie-hash: sha1
    nginx.ingress.kubernetes.io/session-cookie-max-age: "300"
  hosts:
    - host: ""
      paths:
        - path: /graphql
          pathType: Exact
```

If you use ALB of AWS, you can set ingress configurations as follows.

```yaml
ingress:
  enabled: true
  className: alb
  annotations:
    alb.ingress.kubernetes.io/scheme: internal
    alb.ingress.kubernetes.io/target-group-attributes: stickiness.enabled=true,stickiness.lb_cookie.duration_seconds=60
    alb.ingress.kubernetes.io/target-type: ip
    alb.ingress.kubernetes.io/healthcheck-path: /graphql?query=%7B__typename%7D
  hosts:
    - host: ""
      paths:
        - path: /graphql
          pathType: Exact
```

### Image configurations

You must set `image.repository`. Be sure to specify the ScalarDB GraphQL container image so that you can pull the image from the container repository.

```yaml
image:
  repository: <SCALARDB_GRAPHQL_SERVER_CONTAINER_IMAGE>
```

If you're using AWS, refer to [How to install Scalar products through AWS Marketplace](../scalar-kubernetes/AwsMarketplaceGuide.md).

### Database configurations

You must set `scalarDbGraphQlConfiguration`.

If you use ScalarDB Server with ScalarDB GraphQL (recommended), you must set the configuration to access the ScalarDB Server pods.

```yaml
scalarDbGraphQlConfiguration:
  contactPoints: <ScalarDB Server host>
  contactPort: 60051
  storage: "grpc"
  transactionManager: "grpc"
  namespaces: <Schema name includes tables>
```

## Optional configurations

### Resource configurations (Recommended in the production environment)

If you want to control pod resources using the requests and limits of Kubernetes, you can use `resources`.

Note that it is recommended to set at least 2vCPU / 4GB memory if you use the bring-your-own-license (BYOL) containers. Also, if you use the pay-as-you-go (PAYG) containers that the AWS Marketplace provides, you will not be able to run any containers that exceed the 2vCPU / 4GB memory configuration in `resources.limits`. If you exceed this resource limitation, the pods will automatically stop.

You can configure them using the same syntax as the requests and limits of Kubernetes. So, please refer to the official document [Resource Management for Pods and Containers](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) for more details on the requests and limits of Kubernetes.

```yaml
resources:
  requests:
    cpu: 2000m
    memory: 4Gi
  limits:
    cpu: 2000m
    memory: 4Gi
```

### Affinity configurations (Recommended in the production environment)

If you want to control pod deployment using the affinity and anti-affinity of Kubernetes, you can use `affinity`.

You can configure them using the same syntax as the affinity of Kubernetes. So, please refer to the official document [Assigning Pods to Nodes](https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/) for more details on the affinity configuration of Kubernetes.

```yaml
affinity:
  podAntiAffinity:
    preferredDuringSchedulingIgnoredDuringExecution:
      - podAffinityTerm:
          labelSelector:
            matchExpressions:
              - key: app.kubernetes.io/app
                operator: In
                values:
                  - scalardb-graphql
          topologyKey: kubernetes.io/hostname
        weight: 50
```

### Prometheus/Grafana configurations (Recommended in the production environment)

If you want to monitor ScalarDB GraphQL pods using [kube-prometheus-stack](https://github.com/prometheus-community/helm-charts/tree/main/charts/kube-prometheus-stack), you can deploy a ConfigMap, a ServiceMonitor, and a PrometheusRule resource for kube-prometheus-stack using `grafanaDashboard.enabled`, `serviceMonitor.enabled`, and `prometheusRule.enabled`.

```yaml
grafanaDashboard:
  enabled: true
  namespace: monitoring
serviceMonitor:
  enabled: true
  namespace: monitoring
  interval: 15s
prometheusRule:
  enabled: true
  namespace: monitoring
```

### SecurityContext configurations (Default value is recommended)

If you want to set SecurityContext and PodSecurityContext for ScalarDB GraphQL pods, you can use `securityContext` and `podSecurityContext`.

You can configure them using the same syntax as SecurityContext and PodSecurityContext of Kubernetes. So, please refer to the official document [Configure a Security Context for a Pod or Container](https://kubernetes.io/docs/tasks/configure-pod-container/security-context/) for more details on the SecurityContext and PodSecurityContext configurations of Kubernetes.

```yaml
podSecurityContext:
  seccompProfile:
    type: RuntimeDefault

securityContext:
  capabilities:
    drop:
      - ALL
  runAsNonRoot: true
  allowPrivilegeEscalation: false
```

### GraphQL Server configurations (Optional based on your environment)

If you want to change the path to run the graphql queries, you can use `scalarDbGraphQlConfiguration.path`. By default, you can run the graphql queries using `http://<FQDN of ingress>:80/graphql`.

You can also enable/disable [GraphiQL](https://github.com/graphql/graphiql/tree/main/packages/graphiql) using `scalarDbGraphQlConfiguration.graphiql`.

```yaml
scalarDbGraphQlConfiguration:
  path: /graphql
  graphiql: "true"
```

### TLS configurations (Optional based on your environment)

If you want to use TLS between the client and the ingress, you can use `ingress.tls`.

You must create a Secret resource that includes a secret key and a certificate file. Please refer to the official document [Ingress - TLS](https://kubernetes.io/docs/concepts/services-networking/ingress/#tls) for more details on the Secret resource for Ingress.

```yaml
ingress:
  tls:
    - hosts:
        - foo.example.com
        - bar.example.com
        - bax.example.com
      secretName: graphql-ingress-tls
```

### Replica configurations (Optional based on your environment)

You can specify the number of replicas (pods) of ScalarDB GraphQL using `replicaCount`.

```yaml
replicaCount: 3
```

### Logging configurations (Optional based on your environment)

If you want to change the log level of ScalarDB GraphQL, you can use `scalarDbGraphQlConfiguration.logLevel`.

```yaml
scalarDbGraphQlConfiguration:
  logLevel: INFO
```

### Taint and toleration configurations (Optional based on your environment)

If you want to control pod deployment by using the taints and tolerations in Kubernetes, you can use `tolerations`.

You can configure taints and tolerations by using the same syntax as the tolerations in Kubernetes. For details on configuring tolerations in Kubernetes, see the official Kubernetes documentation [Taints and Tolerations](https://kubernetes.io/docs/concepts/scheduling-eviction/taint-and-toleration/).

```yaml
tolerations:
  - effect: NoSchedule
    key: scalar-labs.com/dedicated-node
    operator: Equal
    value: scalardb
```
