Overview
Weaviate is an AI-native vector database for storing, indexing, and querying vector embeddings alongside structured object data. This template deploys a Weaviate 1.38 cluster ofreplicas nodes in a single location, using Raft consensus for schema and cluster state, with one persistent volume per node, optional AI provider modules, and optional scheduled backups to AWS S3 or GCS.
The cluster has no public endpoint by design β it is reachable only from inside Control Plane, scoped by internalAccess.type.
What Gets Created
- Weaviate Workload β A
statefulworkload ofreplicasnodes forming a Raft cluster, serving REST and GraphQL on port8080and gRPC on50051. - Volume Set β One volume per replica holding that nodeβs objects and vector indexes, with autoscaling.
- Credentials Secret β Template-managed
dictionarysecret holding the non-sensitiveapi-uservalue, plus the backup bucket coordinates when backups are enabled. No credential passes through it. - Start Script Secret β The boot script mounted into each container.
- Identity & Policy β An identity bound to the workloads, and a policy granting it
revealon exactly four things at most: the two template secrets, your API key secret, and each AI provider secret you name. Cloud storage access is added to the identity only when backups are enabled. - Backup Cron Workload (optional) β Calls Weaviateβs backup API on a schedule to write a full snapshot to cloud storage.
This template does not create a GVC. You must deploy it into an existing GVC.
Prerequisites
API Key
Weaviate has no anonymous access in this template. The API key is a required prerequisiteopaque secret that must exist before you install β the key never enters the Helm release, and the template only ever refers to it by name.
apiKeySecretName to that name, and set apiUser to the username the key maps to. Keep your own copy of the key: the platform is the only place it is stored, and every client authenticates with it.
AI Provider Keys
Only needed if you want Weaviate to call a provider for embeddings or generative search. Create oneopaque secret per provider, holding just that providerβs key:
modules.openai.apiKeySecretName (or the anthropic, cohere, huggingface equivalent) to that name. Leaving a providerβs apiKeySecretName empty means the provider is genuinely off: no environment variable, no reveal grant, and no outbound internet access on the workload. All three were confirmed against the live resources on a default install, where the container could not reach api.openai.com at all.
Cloud Storage
Only needed if you setbackup.enabled: true. See Backing Up for the bucket, Cloud Account, and IAM steps.
Installation
To install, follow the instructions for your preferred method:UI
Browse, install, and manage templates visually
CLI
Manage templates from your terminal
Terraform
Declare templates in your Terraform configurations
Pulumi
Declare templates in your Pulumi programs
Configuration
The defaultvalues.yaml for this template:
Cluster
replicasβ Number of Weaviate nodes. Three is the default and the practical minimum for Raft, which needs a quorum (2 of 3) to elect a leader and accept schema changes. Read Rolling Restarts Can Split a Replica Out of the Cluster before running a multi-replica cluster in production.imageβ The Weaviate image and tag. The template is tested onsemitechnologies/weaviate:1.38.0.
Authentication
apiKeySecretNameβ Name of the pre-createdopaquesecret whose entire payload is the API key. Required; see Prerequisites. The key is read straight from the secret intoAUTHENTICATION_APIKEY_ALLOWED_KEYSand never appears in the Helm release, the rendered manifest, or the stored workload spec.apiUserβ The username the API key maps to, and the entry in Weaviateβs admin list. This is an identity, not a credential, so it is an ordinary value and is stored in the templateβs own dictionary secret.
401 Unauthorized, and only the exact key from the secret returned 200.
Query Behavior
queryDefaultsLimitβ Default result limit applied to queries that do not specify one.defaultVectorizerModuleβ The vectorizer applied to new collections. Leave it atnonewhen your application supplies its own vectors; set it to a provider module to have Weaviate call that providerβs embedding API on insert and query.
AI Modules
modules.enabledβ List of modules written to WeaviateβsENABLE_MODULESvariable. When backups are enabled the template appendsbackup-s3orbackup-gcsto this list for you.modules.openai.apiKeySecretName,modules.anthropic.apiKeySecretName,modules.cohere.apiKeySecretName,modules.huggingface.apiKeySecretNameβ Name of theopaquesecret holding that providerβs key. Empty means the provider is off.
Naming any provider secret, or enabling backups, opens outbound internet access on the Weaviate workload so it can reach that API. With neither, the workload has no egress at all.
Resources
cpu/memoryβ Limits applied to each Weaviate replica.
vectors Γ dimensions Γ 4 bytes Γ 1.5. Under-provisioning surfaces as an out-of-memory restart rather than slow queries.
Storage
volumes.data.initialCapacityβ Initial volume size in GiB per replica. The platform minimum is 10.volumes.data.autoscaling.maxCapacityβ Maximum volume size in GiB.volumes.data.autoscaling.minFreePercentageβ Free-space percentage that triggers a scale-up.volumes.data.autoscaling.scalingFactorβ Multiplier applied to current capacity when scaling up.
Placement
SetmultiZone.enabled: true to spread replicas across availability zones within the location. Verify the location supports multi-zone before enabling.
Access
internalAccess.typeβ Which workloads may reach Weaviate:none,same-gvc(default),same-org, orworkload-list.internalAccess.workloadsβ Used only withworkload-list. Full workload links, for example//gvc/GVC_NAME/workload/WORKLOAD_NAME.
workload-list was refused, and adding it to the list let it through.
A firewall change takes up to a couple of minutes to take effect. Measured propagation was 45β95 seconds. A denial surfaces to the caller as
HTTP 503 upstream connect error, which is indistinguishable from an unhealthy upstream β re-test after a couple of minutes before concluding a knob did not work.Upgrading From 1.0.1 or Earlier
1.1.0 is a security release. Every credential the chart used to accept as a value is now a secret you create and reference by name, and carrying a 1.0.1 values file forward fails at render with a message naming its replacement β nothing silently falls back to a default.
The render guard for the API key reads:
1
Rotate the key, do not carry it forward
Generate a new key and create the secret as shown in Prerequisites. The old default was public, so an install that used it should be treated as having had its data readable and writable by anyone who found it. If you overrode the default with your own value, that value still travelled in the Helm release and is worth rotating too.
2
Replace the removed keys
Delete
apiKey, clusterName, and any modules.{provider}.apiKey entries from your values. Set apiKeySecretName, rename internal_access to internalAccess, and create a provider secret for each provider you actually use.3
Update every client
The API key changes, so every application, notebook, and client library holding the old bearer token must be updated.
4
Plan the restart
A
helm upgrade restarts the cluster one replica at a time. Read Rolling Restarts Can Split a Replica Out of the Cluster first and verify cluster health afterwards β the platformβs ready status will not tell you if a node failed to rejoin.Cluster Behavior and Known Limits
Both limitations below are pre-existing β1.1.0 changed no clustering configuration β and both were confirmed on a live three-replica cluster.
Rolling Restarts Can Split a Replica Out of the Cluster
A single redeployment of a three-replica cluster left one node permanently split out of the Raft cluster. The restarted node came up as a leaderlessCandidate β it had Raft log entries on disk but had applied none of them, so its schema state was empty. The other two replicas elected a leader without it, and it never rejoined: it was still in that state 31 minutes later, and it did not recover on its own.
The part that makes this dangerous is what the platform reports:
- All three replicas report
ready. The readiness probe checks/v1/.well-known/live, which only proves the HTTP server is up, so the split node stays in the service-DNS rotation. - Roughly a third of client requests fail silently. A 60-sample probe against the load-balanced service DNS measured
200: 42 (70%)and404: 18 (30%)β exactly one node in three. The failures are404 Not Found, an answered, routed response rather than a connection error, so a client sees βno such collectionβ, not βcluster unhealthyβ.
200 while they cycled one at a time.
Check membership from inside any replica. A healthy cluster reports one Leader and two Follower nodes on the same term, and /v1/nodes lists every replica as HEALTHY:
"state":"Candidate" with an empty leaderId and "lastContact":"never", and /v1/nodes queried from a healthy replica lists fewer nodes than you deployed. A single-replica install (replicas: 1) has no Raft membership to lose and is not exposed to this.
Provider Modules Load Regardless of the Module List
modules.enabled does not gate the API-based vectorizer and generative modules. With modules.enabled: [] and only a provider secret named, text2vec-openai was still loaded, a collection could be created with "vectorizer":"text2vec-openai", and inserting an object with no vector made Weaviate call the provider and store the embedding it returned. /v1/meta reports the same 41 modules loaded whether ENABLE_MODULES is set or not β on 1.38 these modules are compiled in and always available.
modules.enabled still has a job β it is the documented upstream knob and it is how the backup modules are turned on, which the template does for you when backup.enabled: true. It is simply not a safety gate on provider access.
Connecting
Weaviate is reachable from workloads inside Control Plane, subject tointernalAccess.type. There is no public endpoint.
Authenticate with the key as a bearer token:
The workload is assigned a canonical
*.cpln.app hostname like any other, but inboundAllowCIDR is empty unconditionally, so every request from the internet is refused at the platform edge with 403 RBAC: access denied β a valid API key does not help, because the request never reaches Weaviate. If you need browser or off-platform access, put your own authenticating proxy in front of it inside the GVC.Backing Up
Withbackup.enabled: true, a cron workload calls Weaviateβs backup API on backup.schedule and writes a full snapshot of every collection to {path}/{backup-id}/ in your bucket.
AWS S3
1
Create a bucket
Create an S3 bucket. Set
backup.aws.bucket and backup.aws.region to match, and backup.aws.path to the prefix you want snapshots written under.2
Set up a Cloud Account
If you do not have one, create a Cloud Account for the AWS account holding the bucket. Set
backup.aws.cloudAccountName to its name.3
Create an IAM policy
Create an IAM policy with the following JSON, replacing
YOUR_BUCKET_NAME, and set backup.aws.policyName to its name:GCS
1
Create a bucket
Create a GCS bucket. Set
backup.gcp.bucket to its name and backup.gcp.path to the prefix.2
Set up a Cloud Account
If you do not have one, create a Cloud Account for the GCP project. Set
backup.gcp.cloudAccountName to its name.3
Grant the bucket role
Grant the Cloud Accountβs service account
roles/storage.objectAdmin on that bucket. The template requests exactly that role on exactly that bucket, and nothing more.Restoring a Backup
Run the restore from inside any Weaviate replica. Usegcs in place of s3 for GCP backups, and replace BACKUP_ID with the backup name from your bucket (they are written as weaviate-backup-YYYYMMDD-HHMMSS):
Important Notes
- Create the API key secret before you install. Without it the install reports success and the deployment silently wedges, with no container and no logs. See Prerequisites.
- Verify cluster health after every restart. A replica that fails to rejoin the Raft cluster still reports
readyand still receives traffic. See Rolling Restarts Can Split a Replica Out of the Cluster. - A named provider secret is a live billable integration, whether or not the module is listed in
modules.enabled. - Keep your own copy of the API key. Rotating it means updating the secret and restarting the cluster; losing it locks you out of every collection.
- There is no public endpoint, and that is not configurable in this template. Reachability is
internalAccessonly, and an access change takes up to a couple of minutes to settle. - Size memory, not CPU. Vector indexes are RAM-resident; an undersized cluster fails with out-of-memory restarts.
- Backups are unverified. Confirm a snapshot lands in your bucket before depending on the schedule.
External References
Weaviate Documentation
Official Weaviate documentation
REST API Reference
REST API reference, including the backup and restore endpoints
Modules
Vectorizer and generative module configuration
Authentication and Authorization
How Weaviate API key authentication and the admin list work
Backups
Upstream documentation for the backup and restore API
Weaviate Template
View the source files, default values, and chart definition