Skip to main content

What is Self-Managed Materialize?

Self-Managed Materialize allows you to deploy and operate Materialize in your own infrastructure using Kubernetes. This deployment model provides complete control over:
  • Infrastructure: Deploy on any Kubernetes cluster (AWS EKS, GCP GKE, Azure AKS, or on-premises)
  • Data residency: Keep all data within your own environment
  • Network configuration: Full control over network policies and connectivity
  • Compliance: Meet strict regulatory requirements for data handling
  • Resource management: Direct control over compute, memory, and storage resources
Self-managed deployments require Kubernetes expertise and operational overhead. Consider Materialize Cloud for a fully-managed option.

Architecture

Self-Managed Materialize runs on Kubernetes using the Materialize Operator:
┌─────────────────────────────────────────────────────┐
│              Kubernetes Cluster                      │
│                                                       │
│  ┌──────────────────────────────────────────┐      │
│  │     Materialize Operator                 │      │
│  │  (orchestratord)                         │      │
│  └──────────────┬───────────────────────────┘      │
│                 │                                    │
│  ┌──────────────▼───────────────────────────┐      │
│  │   Materialize Environment                │      │
│  │                                           │      │
│  │  ┌─────────────┐  ┌────────────────┐    │      │
│  │  │ environmentd │  │   balancerd    │    │      │
│  │  │ (SQL Layer)  │  │ (Load Balancer)│    │      │
│  │  └─────────────┘  └────────────────┘    │      │
│  │                                           │      │
│  │  ┌─────────────────────────────────┐    │      │
│  │  │      clusterd (Workers)          │    │      │
│  │  │  ┌──────┐ ┌──────┐ ┌──────┐     │    │      │
│  │  │  │ Pod  │ │ Pod  │ │ Pod  │     │    │      │
│  │  │  └──────┘ └──────┘ └──────┘     │    │      │
│  │  └─────────────────────────────────┘    │      │
│  │                                           │      │
│  │  ┌─────────────┐                         │      │
│  │  │   console   │                         │      │
│  │  │ (Web UI)    │                         │      │
│  │  └─────────────┘                         │      │
│  └───────────────────────────────────────────┘      │
│                                                       │
│  ┌──────────────┐  ┌─────────────────┐              │
│  │  PostgreSQL  │  │   Object Store  │              │
│  │  (Metadata)  │  │  (S3/Minio)     │              │
│  └──────────────┘  └─────────────────┘              │
└─────────────────────────────────────────────────────┘

Components

Materialize Operator (orchestratord)

The operator manages the lifecycle of Materialize environments:
  • Custom Resource Definitions (CRDs): Define Materialize environments declaratively
  • Reconciliation: Ensures actual state matches desired state
  • Upgrades: Manages rolling upgrades with minimal downtime
  • Scaling: Handles cluster scaling and replica management
Helm chart: misc/helm-charts/operator

environmentd

The SQL interface and query coordinator:
  • Accepts PostgreSQL wire protocol connections on port 6875
  • HTTP API on port 6876
  • Coordinates query execution across compute clusters
  • Manages catalog and metadata
Default resources:
  • CPU: 1 core
  • Memory: 4 GiB

clusterd

Distributed compute workers:
  • Execute data processing and maintain materialized views
  • Run as pods on Kubernetes nodes
  • Scale horizontally based on workload
  • Require local NVMe storage for optimal performance
Resources vary by cluster size (25cc to 6400cc).

balancerd

Load balancer for SQL connections:
  • Distributes connections across environmentd replicas
  • Provides health checking and failover
  • Exposes external SQL endpoint
Default resources:
  • CPU: 500m
  • Memory: 256 MiB

console

Web-based management interface:
  • Environment monitoring and metrics
  • Query history and performance analysis
  • Cluster management UI
  • User and role management
Default resources:
  • CPU: 500m
  • Memory: 256 MiB

Prerequisites

Kubernetes Requirements

  • Kubernetes version: 1.29 or later
  • Helm: 3.2.0 or later
  • Storage: Local NVMe storage with provisioner (OpenEBS recommended)
  • Node requirements:
    • ARM-based CPU (AWS Graviton, GCP Tau, or equivalent)
    • 1:8 ratio of vCPU to GiB memory
    • Local instance storage (for spill-to-disk)

AWS

  • r7g.xlarge to r7g.16xlarge (with local NVMe)
  • r7gd.xlarge to r7gd.16xlarge (with instance store)
  • r6g, r6gd families also supported

GCP

  • n2-standard-* series with local SSDs
  • c2-standard-* series with local SSDs
  • tau-* series (Arm-based)

Azure

  • D-series v5 with local NVMe
  • E-series v5 with local NVMe

External Dependencies

PostgreSQL or CockroachDB (Metadata Store)

Materialize requires a PostgreSQL-compatible database for metadata:
  • PostgreSQL: Version 13 or later
  • CockroachDB: Version 23.1 or later (recommended)
Example connection string:
postgres://materialize_user:[email protected]:5432/materialize_db?sslmode=require

Object Storage (Persist Backend)

Materialize uses object storage for durable data:
  • AWS S3: Recommended for AWS deployments
  • GCS: Recommended for GCP deployments
  • Azure Blob Storage: Recommended for Azure deployments
  • MinIO: For on-premises or testing
Example connection string:
s3://bucket-name/path?endpoint=https://s3.region.amazonaws.com&region=us-east-1

Deployment Options

Kubernetes Deployment

The recommended deployment method using Helm charts:
  • Install Materialize Operator via Helm
  • Deploy Materialize environments using Custom Resources
  • Manage via kubectl and Kubernetes APIs
Learn more →

Docker Deployment

For testing and development:
  • Run Materialize containers with Docker Compose
  • Suitable for local development
  • Not recommended for production
Learn more →

Licensing

Self-managed deployments require a valid license key:
  • Trial licenses: Available for evaluation (contact Materialize)
  • Commercial licenses: Required for production use
  • License enforcement: Newer versions enforce license key checks
Set the license key in your environment secret:
apiVersion: v1
kind: Secret
metadata:
  name: materialize-backend
stringData:
  license_key: "your-license-key-here"
Materialize will not start without a valid license key in recent versions.

Support

Self-managed deployments are supported through:
  • Documentation: Comprehensive deployment guides
  • GitHub: Source code and issue tracking
  • Enterprise support: Available for commercial customers
  • Community: Slack channel for community support

Support Scope

Materialize provides support for:
  • Materialize software issues and bugs
  • Configuration guidance
  • Upgrade assistance
  • Performance tuning recommendations
Customers are responsible for:
  • Kubernetes cluster management
  • Infrastructure provisioning and scaling
  • Backup and disaster recovery operations
  • Monitoring and alerting setup

Comparison: Cloud vs Self-Managed

FeatureMaterialize CloudSelf-Managed
InfrastructureManaged by MaterializeYou manage
KubernetesNot requiredRequired
UpgradesAutomaticManual
ScalingAutomaticManual
MonitoringIncludedYou configure
SLA99.9% uptimeYou manage
Data residencySelect regionFull control
CostCredit-based pricingInfrastructure + license
Support24/7 includedCommercial license
Time to deploy2-3 minutesHours to days
Operational burdenLowHigh

Next Steps

Kubernetes Deployment

Deploy Materialize on Kubernetes using Helm

Docker Deployment

Run Materialize locally with Docker Compose

Configuration Reference

Detailed configuration options and parameters

Operational Guidelines

Best practices for running Materialize in production

Additional Resources

Build docs developers (and LLMs) love