values.yaml

# Default values for ckan-chart.
# This is a YAML-formatted file.
# Declare variables to be passed into your templates.

replicaCount: 1

image:
  repository: keitaro/ckan
  tag: 2.11.0
  pullPolicy: IfNotPresent
  testConnection:
    repository: busybox
    tag: latest
    pullPolicy: IfNotPresent
  initContainer:
    repository: busybox
    tag: latest
    pullPolicy: IfNotPresent  

imagePullSecrets: []
nameOverride: ""
fullnameOverride: "ckan"

pvc:
  enabled: true
  size: "1Gi"
  storageClassName: ""
  accessmode: "ReadWriteOnce"

# DBDeploymentName -- Variable for name override for postgres deployment
DBDeploymentName: &DBDeploymentName postgres

# RedisName -- Variable for name override for redis deployment
RedisName: &RedisName redis

# SolrName -- Variable for name override for solr deployment
SolrName: &SolrName solr

# DatapusherName -- Variable for name override for datapusher deployment
DatapusherName: &DatapusherName datapusher

# DBHost -- Variable for name of headless svc from postgres deployment
DBHost: &DBHost postgres
# MasterDBName -- Variable for name of the master user database in PostgreSQL
MasterDBName: &MasterDBName postgres
# MasterDBUser -- Variable for master user name for PostgreSQL
MasterDBUser: &MasterDBUser postgres
# MasterDBPass -- Variable for password for the master user in PostgreSQL
MasterDBPass: &MasterDBPass pass

# CkanDBName -- Variable for name of the database used by CKAN
CkanDBName: &CkanDBName ckan_default
# CkanDBUser -- Variable for username for the owner of the CKAN database
CkanDBUser: &CkanDBUser ckan_default
# CkanDBPass -- Variable for password for the CKAN database owner
CkanDBPass: &CkanDBPass pass
# DatastoreDBName -- Variable for name of the database used by Datastore
DatastoreDBName: &DatastoreDBName datastore_default
# DatastoreRWDBUser -- Variable for username for the user with write access to the datastore database
DatastoreRWDBUser: &DatastoreRWDBUser datastorerw
# DatastoreRWDBPass -- Variable for password for the datastore database user with write access
DatastoreRWDBPass: &DatastoreRWDBPass pass
# DatastoreRODBUser -- Variable for username for the user with read access to the datastore database
DatastoreRODBUser: &DatastoreRODBUser datastorero
# DatastoreRODBPass -- Variable for password for the datastore database user with read access
DatastoreRODBPass: &DatastoreRODBPass pass

ckan:
  # ckan.sysadminName -- CKAN system admin username
  sysadminName: "ckan_admin"
  # ckan.sysadminPassword -- CKAN system admin password
  sysadminPassword: "PasswordHere"
  # ckan.sysadminApiToken -- CKAN system admin API token
  # Needs to be generated via the CKAN UI and replaced after initial deployment
  sysadminApiToken: "replace_this_with_generated_api_token_for_sysadmin"
  # ckan.sysadminEmail -- CKAN system admin email
  sysadminEmail: "admin@domain.com"
  # ckan.siteTitle -- Site title for the instance
  siteTitle: "Site Title here"
  # ckan.siteId -- Site id
  siteId: "site-id-here"
  # ckan.siteUrl -- Url for the CKAN instance
  siteUrl: "http://localhost:5000"
  # ckan.ckanPlugins -- List of plugins to be used by the instance
  ckanPlugins: "envvars activity image_view datatables_view datastore datapusher"
  # ckan.storagePath -- Storage path to be used by the instance
  storagePath: "/var/lib/ckan/default"
  activityStreamsEmailNotifications: "true"
  debug: "false"
  # To debug inside the ckan container (this sets the entrypoint of the container to sleep infinity)
  container_debug: false
  # uswgi.proc.num -- The number of uswgi workers ckan will start
  uwsg_num: "2"
  # ckan.maintenanceMode -- Set to true to disable CKAN from starting and serve a maintenance page
  maintenanceMode: "false"

  psql:
    # ckan.psql.runOnAzure -- Set to true to run on Azure (if true wont run on anything other then azure) set to false to run on other platforms  
    runOnAzure: false
    # ckan.psql.initialize -- Flag whether to initialize the PostgreSQL instance with the provided users and databases
    initialize: true
    # ckan.psql.masterUser -- PostgreSQL master username
    masterUser: *MasterDBUser
    # ckan.psql.masterPassword -- PostgreSQL master user password
    masterPassword: *MasterDBPass
    # ckan.psql.masterDatabase -- PostgreSQL database for the master user
    masterDatabase: *MasterDBName

  # ckan.solr -- Location of SOLR collection used by the instance
  solr: "http://solr-headless:8983/solr/ckancollection"
  # ckan.redis -- Location of the Redis service to be used by the CKAN instance
  redis: "redis://redis-headless:6379/0"

  spatialBackend: "solr"

  locale:
    offered: "en"
    default: "en"
  # ckan.datapusherUrl -- Location of the datapusher service to be used by the CKAN instance
  datapusherUrl: "http://datapusher-headless:8000"
  # ckan.datapusherCallbackUrlBase -- Location of the CKAN k8s service to be used by the Datapusher, overriding the default site url route.
  datapusherCallbackUrlBase: http://ckan
  smtp:
    server: "smtpServerURLorIP:port"
    user: "smtpUser" 
    password: "smtpPassword"
    mailFrom: "postmaster@domain.com"
    tls: "enabled"
    starttls: "true"
  issues:
    sendEmailNotifications: "true"

  # ckan.extraEnv -- An array to add extra environment variables
  # For example:
  # extraEnv:
  #   - name: FOO
  #     value: "bar"
  #

  extraEnv: []

  readiness:
    # ckan.readiness.initialDelaySeconds -- Inital delay seconds for the readiness probe
    initialDelaySeconds: 10
    #  ckan.readiness.periodSeconds -- Check interval for the readiness probe
    periodSeconds: 10
    # ckan.readiness.failureThreshold -- Failure threshold for the readiness probe
    failureThreshold: 6
    # ckan.readiness.timeoutSeconds -- Timeout interval for the readiness probe
    timeoutSeconds: 10

  liveness:
    # ckan.liveness.initialDelaySeconds -- Initial delay for the liveness probe
    initialDelaySeconds: 10
    # ckan.liveness.periodSeconds -- Check interval for the liveness probe
    periodSeconds: 10
    # ckan.liveness.failureThreshold -- Failure threshold for the liveness probe
    failureThreshold: 6
    # ckan.liveness.timeoutSeconds -- Timeout interval for the liveness probe
    timeoutSeconds: 10

  db:
    # ckan.db.ckanDbUrl -- Url of the PostgreSQL server where the CKAN database is hosted
    ckanDbUrl: *DBHost
    # ckan.db.ckanDbName -- Name of the database to be used by CKAN
    ckanDbName: *CkanDBName
    # ckan.db.ckanDbUser -- Username of the database to be used by CKAN
    ckanDbUser: *CkanDBUser
    # ckan.db.ckanDbPassword -- Password of the user for the database to be used by CKAN
    ckanDbPassword: *CkanDBPass

  datastore:
    # ckan.datastore.RwDbUrl -- Url of the PostgreSQL server where the datastore database is hosted
    RwDbUrl: *DBHost
    # ckan.datastore.RwDbName -- Name of the database to be used for Datastore
    RwDbName: *DatastoreDBName
    # ckan.datastore.RwDbUser -- Username for the datastore database with write permissions
    RwDbUser: *DatastoreRWDBUser
    # ckan.datastore.RwDbPassword -- Password for the datastore write permissions user
    RwDbPassword: *DatastoreRWDBPass
    # ckan.datastore.RoDbUrl -- Url of the PostgreSQL server where the datastore database is hosted
    RoDbUrl: *DBHost
    # ckan.datastore.RoDbName -- Name of the database to be used for Datastore
    RoDbName: *DatastoreDBName
    # ckan.datastore.RoDbUser -- Username for the datastore database with read permissions
    RoDbUser: *DatastoreRODBUser
    # ckan.datastore.RoDbPassword -- Password for the datastore read permissions user
    RoDbPassword: *DatastoreRODBPass

serviceAccount:
  # serviceAccount.create -- Specifies whether a service account should be created
  create: false
  # serviceAccount.annotations -- Annotations to add to the service account
  annotations: {}
  # serviceAccount.name -- The name of the service account to use.
  # If not set and create is true, a name is generated using the fullname template
  name:

# labels.ckan -- A map where you can add extra labels to the ckan deployment:
# example:
# ckan:
#   test: label1

labels:
  enabled: false
  ckan: []

podSecurityContext: {}
  # fsGroup: 2000

securityContext: {}
  # capabilities:
  #   drop:
  #   - ALL
  # readOnlyRootFilesystem: true
  # runAsNonRoot: true
  # runAsUser: 1000

service:
  # service.type -- Type of the service created for the CKAN pod
  type: ClusterIP
  port: 80

ingress:
  enabled: false
  annotations: {}
    # kubernetes.io/ingress.class: nginx
    # kubernetes.io/tls-acme: "true"
  className: ""
  hosts:
    - host: chart-example.local
      paths:
        - path: /
          pathType: ImplementationSpecific
  tls: []
  #  - secretName: chart-example-tls
  #    hosts:
  #      - chart-example.local

# ingressRoute -- Used in conjunction with a Traefik v2 deployment
ingressRoute:
  enabled: false
  host: chart-example.local

resources: {}
  # We usually recommend not to specify default resources and to leave this as a conscious
  # choice for the user. This also increases chances charts run on environments with little
  # resources, such as Minikube. If you do want to specify resources, uncomment the following
  # lines, adjust them as necessary, and remove the curly braces after 'resources:'.
  # limits:
  #   cpu: 100m
  #   memory: 128Mi
  # requests:
  #   cpu: 100m
  #   memory: 128Mi

nodeSelector: {}

tolerations: []

affinity: {}

hpa:
  enabled: false
  minReplicas: 1
  maxReplicas: 5
  cpuTargetAverageUtilization: 80
  memoryTargetAverageUtilization: 80
  sessions:
    session_url: redis://redis-headless:6379/0
    session_type: ext:redis

datapusher:
 # datapusher.enabled -- Flag to control whether to deploy the datapusher
  enabled: true
  # datapusher.fullnameOverride -- Name override for the datapusher deployment
  fullnameOverride: *DatapusherName
  datapusher:
    # datapusher.datapusher.maxContentSize -- Maximum size of content to be uploaded in bytes.
    maxContentLength: "102400000"
    # datapusher.datapusher.chunkSize -- Size of chunks of the data that is being downloaded in bytes
    chunkSize: "10240000"
    # datapusher.datapusher.insertRows -- Number of rows to take from the data and upload them as chunks to datastore
    insertRows: "50000"
    # datapusher.datapusher.downloadTimeout -- Timeout limit of the download request
    downloadTimeout: "300"
    # datapusher.datapusher.datapusherSslVerify -- Enable or disable (boolean) verification of SSL when trying to get resources. Default: True
    datapusherSslVerify: "False"
    # datapusher.datapusher.datapusherRewriteResources -- Enable or disable (boolean) whether datapusher should rewrite resources uploaded to CKAN's filestore, since datapusher takes the CKAN Site URL value for generating the resource URL. Default: False
    datapusherRewriteResources: "True"
    # datapusher.datapusher.datapusherRewriteUrl -- Sets the rewrite URL that datapushed will rewrite resources that are uploaded to CKAN's filestore. Default: http://ckan:5000
    datapusherRewriteUrl: http://ckan

redis:
  # Please see all available overrides at https://github.com/bitnami/charts/tree/master/bitnami/redis
  # redis.enabled -- Flag to control whether to deploy Redis
  enabled: true
  # redis.fullnameOverride -- Name override for the redis deployment
  fullnameOverride: *RedisName
  replicaCount: 1
  # redis.architecture -- Redis architecture for standalone or replication versions
  architecture: standalone
  master:
    persistence:
      # redis.master.persistence.enabled -- Enable redis volume claim
      enabled: false
      # redis.master.persistence.size -- Size of the volume claim
      size: 1Gi
  auth:
  # redis.auth.enabled -- Enable or disable redis password auth
    enabled: false
  # redis.auth.sentinel -- Enables or disables passwords for sentinels
    sentinel: false
  # redis.auth.password --  The password of redis if auth is enabled
    password: 


solr: 
  # Please see all available overrides at https://github.com/bitnami/charts/tree/master/bitnami/solr/#installing-the-chart
  # solr.enabled -- Flag to control whether to deploy SOLR
  enabled: true
  global:
    imageRegistry: ""
    imagePullSecrets: []
    storageClass: ""
  auth:
  # solr.auth.enabled -- Enable or disable auth (if auth is disabled solr-init cant upload the configset/schema.xml for ckan)
    enabled: true
  # solr.auth.adminUser -- The name of the solr admin user
    adminUsername: admin
  # solr.auth.adminPassword -- The password of the solr admin user
    adminPassword: pass
  # solr.collection -- the name of the collection created by solr 
  # since we are creating one with solr-init this needs to be blank
  collection:
  # solr.collectionShards -- Number of shards for the SOLR collection
  collectionShards: 
  # solr.collectionReplicas -- Number of replicas for each SOLR shard
  collectionReplicas: 
  # solr.fullnameOverride -- Name override for the SOLR deployment
  fullnameOverride: *SolrName
  # solr.replicaCount -- Number of SOLR instances in the cluster
  replicaCount: 1
  volumeClaimTemplates:
    # solr.volumeClaimTemplates.storageSize -- Size of Solr PVC
    storageSize: 5Gi
  image:
    registry: docker.io
    # solr.image.repository -- Repository for the SOLR image
    repository: bitnami/solr
    # solr.image.tag -- Tag for the SOLR image
    tag: 8.11.1
  zookeeper:
    # solr.zookeeper.replicaCount -- Numer of Zookeeper replicas in the ZK cluster
    replicaCount: 1
    persistence:
      # solr.zookeeper.persistence.size -- Size of ZK PVC
      size: 1Gi

  initialize:
    # solr.initialize.enabled -- Flag whether to initialize the SOLR instance with the provided collection name
    enabled: true
    # solr.initialize.numShards -- Number of shards for the SOLR collection
    numShards: 2
    # solr.initialize.replicationFactor -- Number of replicas for each SOLR shard
    replicationFactor: 1
    # solr.initialize.maxShardsPerNode -- Maximum shards per node
    maxShardsPerNode: 10
    # solr.initialize.configsetName -- Name of the config set used for initializing
    configsetName: ckanConfigSet


postgresql:
  # postgresql.enabled -- Flag to control whether to deploy PostgreSQL
  enabled: true
  persistence:
    # postgresql.persistence.size -- Size of the PostgreSQL pvc
    size: 1Gi
  # postgresql.fullnameOverride -- Name override for the PostgreSQL deployment
  fullnameOverride: *DBDeploymentName
  # @param postgresql.auth.postgresPassword Password for the "postgres" admin user (overrides `auth.postgresPassword`)
  # @param postgresql.auth.username Name for a custom user to create (overrides `auth.username`)
  # @param postgresql.auth.password Password for the custom user to create (overrides `auth.password`)
  # @param postgresql.auth.database Name for a custom database to create (overrides `auth.database`)
  # @param postgresql.auth.existingSecret Name of existing secret to use for PostgreSQL credentials (overrides `auth.existingSecret`).
  # @param postgresql.auth.secretKeys.adminPasswordKey Name of key in existing secret to use for PostgreSQL credentials (overrides `auth.secretKeys.adminPasswordKey`). Only used when `global.postgresql.auth.existingSecret` is set.
  # @param postgresql.auth.secretKeys.userPasswordKey Name of key in existing secret to use for PostgreSQL credentials (overrides `auth.secretKeys.userPasswordKey`). Only used when `global.postgresql.auth.existingSecret` is set.
  # @param postgresql.auth.secretKeys.replicationPasswordKey Name of key in existing secret to use for PostgreSQL credentials (overrides `auth.secretKeys.replicationPasswordKey`). Only used when `global.postgresql.auth.existingSecret` is set.
  auth:
    postgresPassword: *MasterDBPass
    username: *CkanDBUser
    password: *CkanDBPass
    database: *CkanDBName
    # existingSecret: ""
    # secretKeys:
    #   adminPasswordKey: ""
    #   userPasswordKey: ""
    #   replicationPasswordKey: ""