Kubernetes (Enterprise)

Enterprise

This guide installs Parseable Enterprise in distributed mode on Kubernetes. The installation creates ingestor, querier, and Prism nodes.

To install Parseable OSS, use the distributed OSS Kubernetes guide.

1. Prerequisites

Before you begin, make sure you have:

kubectl configured for your Kubernetes cluster
Helm 3 or later
A Kubernetes storage class
An existing, empty object-store bucket with access credentials
parseable_license.json and parseable_license.sig from Parseable

A valid Enterprise license is required to run Parseable Enterprise. If you do not have a license, contact sales@parseable.com; the Enterprise deployment cannot run without it.

Confirm the Kubernetes context and find an available storage class:

kubectl config current-context
kubectl get nodes
kubectl get storageclass

2. Create the namespace

kubectl create namespace parseable

3. Choose an object store

Choose exactly one object store below. Replace every <...> placeholder in the selected option before running the command.

After completing one option, continue to step 4.

Option A: MinIO

This single-node MinIO setup is for testing only. Skip the installation if you already have a MinIO or another S3-compatible object store.

Install MinIO and create a bucket named parseable:

helm repo add minio https://charts.min.io/
helm install --namespace minio --create-namespace --set "buckets[0].name=parseable,buckets[0].policy=none,buckets[0].purge=false,rootUser=minioadmin,rootPassword=minioadmin,replicas=1,persistence.enabled=true,persistence.storageClass="",resources.requests.memory=128Mi,mode=standalone" minio minio/minio

Forward the MinIO console port:

kubectl port-forward svc/minio-console -n minio 9001:9001

Open http://localhost:9001. A bucket named parseable should be available.

Create a file named parseable-env-secret. These defaults work with the MinIO installation above:

cat << EOF > parseable-env-secret
s3.url=http://minio.minio.svc.cluster.local:9000
s3.access.key=minioadmin
s3.secret.key=minioadmin
s3.region=us-east-1
s3.bucket=parseable
addr=0.0.0.0:8000
username=admin
password=admin
EOF

These credentials are for testing only. Before creating the Kubernetes Secret, replace the MinIO and Parseable administrator credentials with secure values that match your MinIO deployment.

Use s3-store in enterprise-values.yaml.

Option B: Amazon S3

Create a file named parseable-env-secret using the bucket, region, access key, and secret key provided by your AWS administrator:

cat <<'EOF' > parseable-env-secret
addr=0.0.0.0:8000
username=admin
password=<password>
s3.url=<s3.url>
s3.access.key=<s3.access.key>
s3.secret.key=<s3.secret.key>
s3.bucket=<s3.bucket>
s3.region=<s3.region>
EOF

Use s3-store in enterprise-values.yaml.

Option C: Google Cloud Storage

Create a file named parseable-env-secret using the bucket details provided by your Google Cloud administrator:

cat <<'EOF' > parseable-env-secret
addr=0.0.0.0:8000
username=admin
password=<password>
gcs.url=<gcs.url>
gcs.bucket=<gcs.bucket>
EOF

Keep the service-account JSON file ready. You will create its Kubernetes Secret after creating the main Secret.

The service-account JSON file is a credential. Store it securely and never commit it to source control.

Use gcs-store in enterprise-values.yaml.

Option D: Azure Blob Storage

Create a file named parseable-env-secret using the storage account, container, and access key provided by your Azure administrator:

cat <<'EOF' > parseable-env-secret
addr=0.0.0.0:8000
username=admin
password=<password>
azr.access_key=<azr.access_key>
azr.account=<azr.account>
azr.container=<azr.container>
azr.url=<azr.url>
EOF

Use blob-store in enterprise-values.yaml.

4. Create the Kubernetes Secret

After creating the file for your selected object store, review it and create the Kubernetes Secret:

chmod 600 parseable-env-secret

kubectl create secret generic parseable-env-secret \
  --namespace parseable \
  --from-env-file=parseable-env-secret

If you selected Google Cloud Storage, also create the service-account key Secret:

kubectl create secret generic parseable-gcs-key \
  --namespace parseable \
  --from-file=key.json='<path-to-service-account-json>'

You can add supported environment variables to parseable-env-secret as needed. See the environment variables documentation.

After confirming that the Kubernetes Secret exists, delete the local plaintext file:

rm parseable-env-secret

5. Create Enterprise Secrets

Create the license Secret. Replace <license-directory> with the directory containing both license files:

kubectl create secret generic parseable-license \
  --namespace parseable \
  --from-file=parseable_license.json='<license-directory>/parseable_license.json' \
  --from-file=parseable_license.sig='<license-directory>/parseable_license.sig'

Create a random 16-character shared Secret for communication between Enterprise nodes:

kubectl create secret generic parseable-cluster-secret \
  --namespace parseable \
  --from-literal=cluster-secret="$(openssl rand -hex 8)"

6. Add the Parseable Helm repository

helm repo add parseable https://charts.parseable.com
helm repo update parseable

7. Create `enterprise-values.yaml`

Create a file named enterprise-values.yaml:

parseable:
  deploymentMode: distributed

  store:
    # MinIO and Amazon S3: s3-store
    # Google Cloud Storage: gcs-store
    # Azure Blob Storage: blob-store
    type: s3-store
    secretName: parseable-env-secret
 # Google Cloud Storage only: uncomment this block.
 # gcsCredentials:
 #   secretName: parseable-gcs-key
 #   secretKey: key.json
 #   mountPath: /var/secrets/google

  clusterSecret:
    enabled: true
    secretName: parseable-cluster-secret
    secretKey: cluster-secret

  enterprise:
    enabled: true
    license:
      secretName: parseable-license
      mountPath: /tmp/license
      dataKey: parseable_license.json
      signatureKey: parseable_license.sig
  distributed:
    ingestor:
      replicas: 3
      resources:
        requests:
          cpu: 250m
          memory: 1Gi
        limits:
          cpu: 500m
          memory: 4Gi
      persistence:
        staging:
          enabled: true
          storageClass: <storage-class>
          accessMode: ReadWriteOnce
          size: 5Gi

    querier:
      replicas: 1
      resources:
        requests:
          cpu: 250m
          memory: 1Gi
        limits:
          cpu: 500m
          memory: 4Gi
      persistence:
        hotTier:
          enabled: true
          storageClass: <storage-class>
          accessMode: ReadWriteOnce
          size: 100Gi

    prism:
      replicas: 1
      resources:
        requests:
          cpu: 500m
          memory: 1Gi
        limits:
          cpu: "1"
          memory: 2Gi

Before continuing:

Set parseable.store.type for the object store selected in step 3.
If you selected Google Cloud Storage, uncomment the gcsCredentials block.
Replace both <storage-class> placeholders with a storage class returned by kubectl get storageclass.
Adjust replicas, CPU, memory, and volume sizes for your workload.

8. Install Parseable Enterprise

helm upgrade --install parseable parseable/parseable \
  --namespace parseable \
  --values ./enterprise-values.yaml \
  --wait \
  --timeout 10m

9. Verify the installation

helm status parseable --namespace parseable
kubectl get pods,pvc,services,statefulsets --namespace parseable

The ingestor, querier, and Prism pods should be Running, and all PVCs should be Bound.

10. Access Parseable

Forward the Prism service:

kubectl port-forward \
  service/parseable-prism-service 8000:80 \
  --namespace parseable

Open http://localhost:8000 and sign in with the administrator credentials used in parseable-env-secret.

Send ingestion traffic inside the cluster to:

http://parseable-ingestor-service.parseable.svc.cluster.local

11. Troubleshooting

Start with Prism, then the querier, and then the ingestors:

kubectl get events --namespace parseable --sort-by=.lastTimestamp
kubectl logs statefulset/parseable-prism --namespace parseable
kubectl logs statefulset/parseable-querier --namespace parseable
kubectl logs statefulset/parseable-ingestor --namespace parseable

License errors usually indicate missing, incorrectly named, or invalid license files.
Pending PVCs usually indicate an invalid storage class or unavailable volume provisioner.
CreateContainerConfigError usually indicates a missing Secret or Secret key.
Object-store authentication errors usually indicate incorrect credentials, permissions, endpoint, bucket, or container values.
Use an empty bucket or container for a new Parseable cluster. Metadata from another Parseable cluster can cause credential or deployment identity conflicts.

Kubernetes (Enterprise)

On this page