Configuration Reference

The installation of GoodData.CN is configured using a Helm chart. You can download the most up-to-date version of the GoodData Helm chart from https://charts.gooddata.com using Helm. Every value the chart accepts is listed in the Helm Chart Values Reference.

Before installing the GoodData.CN Helm chart, you should create a YAML file to override the default Helm chart values with configurations tailored to your specific installation requirements.

The Configuration Assistant builds that file for you. Answer a short series of questions about your platform, database, storage, and hostnames, and it assembles the Helm values for GoodData.CN and Pulsar, the size profile for your deployment, and the Organization custom resource. It runs entirely in your browser, so nothing you enter leaves your machine. Start there, then use the reference below to fine-tune individual options.

Open the Configuration Assistant

Save Your YAML Configuration File

We strongly recommend saving the YAML configuration file used during installation. This file will be essential when upgrading GoodData.CN to a newer version.

Common Options

This section provides a non-exhaustive list of common configuration options you may want to consider when installing GoodData.CN.

OIDC Provider

By default, GoodData.CN installs with an internal OpenID Connect (OIDC) identity provider called Dex. For production deployments, we strongly recommend using your own external OIDC identity provider and disabling Dex with the following configuration:

deployDexIdP: false

You can configure GoodData.CN to use your external OIDC provider after the Helm chart installation by adjusting the organization settings.

If you decide to keep Dex enabled, you’ll need to configure the ingress host where the identity provider will be running:

dex:
  ingress:
    authHost: 'auth.company.com'
    tls:
      authSecretName: gooddata-cn-auth-tls
  # annotations:
  #   cert-manager.io/cluster-issuer: letsencrypt-production

The example annotation shows how to integrate with cert-manager to provision TLS certificates automatically. If you are not using automated certificate provisioning, ensure that the gooddata-cn-auth-tls secret already exists and contains a certificate and key valid for the auth.company.com DNS name. Also, ensure that auth.company.com resolves to the Load Balancer in front of your ingress controller.

General recommendation: For production installations you should disable Dex and use external OIDC identity provider instead.

Istio (Service Mesh & Gateway)

GoodData.CN can run behind Istio’s ingress gateway using a shared Gateway and per‑organization VirtualService objects. Enable it with:

istio:
  enabled: true

Key points:

  • Ingress objects are not created; Istio Gateway/VirtualService are used instead.
  • A shared Gateway is required to support wildcard certificates; the organization controller manages one shared Gateway and a VirtualService per Organization.
  • Envoy limitations apply:
    • Do not combine overlapping wildcard and single‑host certificates on the same Gateway.
    • Do not reuse the same wildcard certificate across multiple Gateways or deployments.
    • If Dex is used, place it on a separate hostname with its own certificate (outside the wildcard domain).

See detailed guidance in Istio Service Mesh and Gateway.

Ingress

ingress.ingressClassName selects the IngressClass of the controller that serves the chart’s Ingress objects. Set it when more than one ingress controller is available in the cluster.

ingress:
  ingressClassName: nginx

Network Policies

Set networkPolicy.enabled to true to have the chart create NetworkPolicy resources that restrict pod-to-pod access. Match the selectors to your ingress controller so ingress traffic is still allowed.

networkPolicy:
  enabled: true
  ingressControllerNamespaceLabelSelector:
    kubernetes.io/metadata.name: ingress-nginx
  ingressControllerPodLabelSelector:
    app.kubernetes.io/name: ingress-nginx

Pod Security

If your cluster enforces a Pod Security Standards restricted policy set through OPA Gatekeeper, Kyverno, or Pod Security Admission, set restrictedPodSecurity.enabled to true and add the labels your policy requires under commonLabels. For the full values files, including the matching Apache Pulsar configuration, see Harden the Deployment for Restricted Admission Policies.

restrictedPodSecurity:
  enabled: true
commonLabels:
  example.com/owner: analytics-platform

PostgreSQL

GoodData.CN requires an externally managed PostgreSQL database. The bundled postgresql-ha subchart was removed in 4.0, so you must provision PostgreSQL yourself and point the chart at it with service.postgres.*:

service:
  postgres:
    # specify hostname of your remote postgresql server
    host: postgres.database.example.com
    port: 5432
    username: postgres #If you use Azure Database for PostgreSQL, the username must contain the hostname e.g. postgres@gooddata-cn-pg.
    password: secretpassword123
    # existingSecret: ''

Optionally, you can create a Kubernetes secret with the key postgresql-password containing the password for the postgres user. Specify the name of this secret in existingSecret instead of using the password key.

For sizing and managed-service recommendations (Amazon RDS, Azure Database for PostgreSQL), see the production deployment guides. If you are moving off the removed postgresql-ha subchart, follow Upgrade to GoodData.CN 4.0.

Redis

GoodData.CN can be configured to use an external Redis service for caching. To do this, update your configuration as follows:

deployRedisHA: false
service:
  redis:
    # specify list of your redis servers
    hosts:
      - redis.cache.example.com
    port: 6379
    clusterMode: false
    # If your Redis service has authentication enabled, uncomment and declare the password
    # password: <REDIS_PASSWORD>
    # existingSecret: ''

You may also create a Kubernetes secret with the key redis-password containing the Redis password. Specify the name of this secret in existingSecret instead of using the password key.

General recommendation: Using the default internal Redis is generally sufficient for most cases.

Storage

If you have the option to access AWS S3, configure storage using the following snippet:

exportController:
  fileStorageBaseUrl: 's3://s3.<region>.amazonaws.com/<bucket>/<prefix>'
  s3:
    # -- AWS access key id of IAM account with access to S3 bucket
    accessKey: ''
    # -- AWS secret access key of IAM account with access to S3 bucket
    secretKey: ''
  # -- you can specify existing secret with cloud credentials instead.
  # It must contain keys `access-key-id` and `secret-access-key`
  existingSecret: ''

quiver:
  durableStorageType: S3
  s3DurableStorage:
    s3Bucket: my-bucket
    s3BucketPrefix: someprefix
    s3Region: us-east-2
    # s3AccessKey: AKIAxxxxxxx
    # s3SecretKey: xxxxxxxxxxx
    # authType: aws_tokens

There are three ways to provide AWS credentials:

  • Use accessKey and secretKey.

  • Create a Kubernetes secret with access-key-id and secret-access-key, and specify its name in existingSecret.

  • (AWS deployments only): Use workload identity federation (IRSA). Configure your ServiceAccount with the appropriate IAM role and enable cloud identity in Helm:

    cloudIdentity:
      enabled: true
      aws:
        roleArn: "arn:aws:iam::<account-id>:role/<role-name>"
        region: "us-east-1"

    cloudIdentity.* centralizes region and role configuration for workload identity federation. Your cloud provider may still require provider-specific annotations on the ServiceAccount. Set them with serviceAccount.annotations.

We recommend setting up a lifecycle policy to automatically delete objects older than one day from the bucket.

Alternatively, if S3 cannot be used, you can attach a volume with the ReadWriteMany access mode. You’ll need a StorageClass that supports this access mode, configured as follows:

exportController:
  # -- Base url for export file storage. Must be a local directory
  fileStorageBaseUrl: '/tmp/exports'
  fsExportStorage:
    # -- External storage class name providing ReadWriteMany accessMode
    storageClassName: ""
    # -- Size of the export storage volume.
    pvcRequestStorageSize: "1Gi"

quiver:
  durableStorageType: FS
  fsDurableStorage:
    storageClassName: efs-csi

Note that there is no automatic cleanup job for old files in this setup, so you should implement your own.

The size of the persistent volume for FlexCache durable storage is set in resultCache.totalCacheLimit (default: 32 GiB).

General recommendation: Configuring storage is mandatory.

Metadata Encryption

Sensitive metadata, such as data source credentials, should be encrypted. For the full procedure, see Encrypt Metadata and Data Source Credentials.

License Key

GoodData.CN requires a valid license key to start. Store it in a Kubernetes Secret and reference it with license.existingSecret:

license:
  existingSecret: gdcn-license

Enter the key on a single line, exactly as you received it, without adding or removing any characters or spaces. If the key is modified, GoodData.CN fails to start. To renew an expired key, recreate the Secret with the new key; the deployment picks it up within a few minutes. For the secret-creation command, see Production Deployment. If you cannot locate your key, contact GoodData Support.

Container Registry

image.repositoryPrefix (GoodData.CN images) and image.dockerhubPrefix (third-party images) point the chart at a different registry host. Set both to your local registry namespace for air-gapped deployments.

image:
  repositoryPrefix: registry.company.com/gooddata
  dockerhubPrefix: registry.company.com/dockerhub

Prometheus Monitoring

Set podMonitor.enabled to true to create PodMonitor objects for the Prometheus Operator.

podMonitor:
  enabled: true

See Observability for the metrics exposed and how to consume them.

Platform Limits

platform_limits.* adjusts data limits such as maximum result size, dimension size, and export timeouts. See Change Execution Limits.

Pod Disruption Budgets

<service>.podDisruptionBudget limits how many pods of a service can be disrupted at once, so voluntary disruptions such as node drains do not take a service down.

metadataApi:
  podDisruptionBudget:
    maxUnavailable: 1

Replica Counts

<service>.replicaCount sets the number of pod replicas per service. Reducing it to 1 saves resources while testing, but is not recommended for production.

metadataApi:
  replicaCount: 1

Examples

For a complete, worked example of a production Helm values file, see Production Deployment and switch the AWS/Azure tabs to your platform.