Kubernetes (OSS)

1. Create the namespace

kubectl create namespace parseable

If you are testing in a shared cluster, use a separate namespace for your test installation and replace parseable in the commands below with that namespace.

2. Choose a storage option

Choose exactly one storage option below. Replace every <...> placeholder in the selected option before creating the Kubernetes Secret.

After completing one option, continue to step 4.

Option A: Local storage

Create a file named parseable-env-secret:

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

Use local-store in standalone-values.yaml.

Option B: MinIO

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 using the MinIO test credentials:

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

Use s3-store in standalone-values.yaml.

Option C: Amazon S3

Create a file named parseable-env-secret using the bucket credentials 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 standalone-values.yaml.

Option D: 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.

Use gcs-store in standalone-values.yaml.

Option E: Azure Blob Storage

Create a file named parseable-env-secret using the storage credentials 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 standalone-values.yaml.

3. Create the Kubernetes Secret

Review the file created for your selected storage option, then create the 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>'

Confirm that the required Secrets exist without displaying their values:

kubectl get secret parseable-env-secret --namespace parseable
kubectl get secret parseable-gcs-key --namespace parseable

The second command is required only for Google Cloud Storage.

Delete the local plaintext configuration file after creating the Secret:

rm parseable-env-secret

4. Add the Parseable Helm repository

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

5. Create standalone-values.yaml

Create a file named standalone-values.yaml:

parseable:
  deploymentMode: standalone

  image:
    repository: quay.io/parseablehq/parseable
    tag: "" # Defaults to the Helm chart appVersion
    pullPolicy: IfNotPresent

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

  standalone:
    unified:
      env:
        RUST_LOG: warn
      resources:
        requests:
          cpu: 250m
          memory: 1Gi
        limits:
          cpu: 500m
          memory: 4Gi
      persistence:
        staging:
          enabled: true
          storageClass: <storage-class>
          accessMode: ReadWriteOnce
          size: 5Gi
        data:
          enabled: true
          storageClass: <storage-class>
          accessMode: ReadWriteOnce
          size: 5Gi

To enable OIDC, add the variables under parseable.standalone.unified.env. See the OIDC guide.

Before continuing:

1. Set parseable.store.type for the storage option selected in step 3.
2. If you selected Google Cloud Storage, uncomment the gcsCredentials block.
3. Replace each enabled volume's <storage-class> with a storage class returned by kubectl get storageclass.
4. Adjust volume sizes for your workload.

You can render the chart before installing it:

helm template parseable parseable/parseable \
  --namespace parseable \
  --values ./standalone-values.yaml

This catches invalid storage combinations before anything is created in the cluster.

Storage behavior

• staging.enabled: true creates a staging PVC. false uses emptyDir, so pending staged data is lost if the Pod is replaced.
• With local-store, data.enabled: true creates a data PVC. false uses emptyDir, so stored data is lost if the Pod is replaced.
• If local-store data is disabled, staging must also be disabled. The chart rejects persistent staging with temporary local data.
• With S3, GCS, or Azure Blob Storage, permanent data is stored in the object store. The chart does not create or mount a data volume.
• Choose between PVC and emptyDir during installation. Changing that choice later requires recreating the StatefulSet.
• Kubernetes rejects changing a volume claim template's size on an existing StatefulSet. If the StorageClass supports volume expansion, resize the generated PVC directly.

6. Install Parseable

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

7. Verify the installation

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

The Parseable pod should be Running, and every created PVC should be Bound. With the release name parseable, a standalone local-store install with both staging and data persistence enabled creates two PVCs:

• stage-volume-parseable-standalone-0
• data-volume-parseable-standalone-0

8. Access Parseable

kubectl port-forward service/parseable-standalone-service 8000:80 --namespace parseable

Open http://localhost:8000 and sign in with the username and password stored in parseable-env-secret.

9. Troubleshooting

kubectl get events --namespace parseable --sort-by=.lastTimestamp
kubectl describe pod --namespace parseable -l app.kubernetes.io/instance=parseable
kubectl logs statefulset/parseable-standalone --namespace parseable --tail=200

• 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 installation.