Configuration Reference

Complete values.yaml configuration guide for Composio Helm Charts

Global Secrets Apollo Thermos Mercury Temporal Minio Redis Observability

Global Configuration

Namespace Settings

Parameter	Description	Default	Required
`namespace.create`	Create namespace automatically	`false`	No
`namespace.name`	Namespace for Composio services	`"composio"`	No
`global.environment`	Deployment environment	`"development"`	No
`global.domain`	Base domain for services	`"localhost"`	No

Example Configuration:
                            namespace:
  create: true
  name: "composio-prod"

global:
  environment: production
  domain: "composio.example.com"
  imagePullSecrets:
    - name: ecr-secret
                        

Secrets & External Services

External Secrets Configuration

Parameter	Description	Required	Set Via
`externalSecrets.ecr.token`	AWS ECR authentication token	Yes	--set flag
`externalSecrets.ecr.server`	ECR registry server URL	Yes	values.yaml
`externalSecrets.ecr.username`	ECR username (typically "AWS")	Yes	values.yaml

Setting Secrets via Environment Variables:
                            # Required: PostgreSQL connection string
export POSTGRES_URL="postgresql://user:password@host:5432/db?sslmode=require"

# Optional: External Redis
export REDIS_URL="redis://user:password@host:6379/0"

# Optional: OpenAI API key
export OPENAI_API_KEY="sk-1234567890..."

# Run secret setup script
./secret-setup.sh -r composio -n composio
                        

Database Configuration

Parameter	Description	Default
`externalPostgreSQL.enabled`	Use external PostgreSQL database	`true`
`externalRedis.enabled`	Use external Redis	`true`
`redis.enabled`	Deploy bundled Redis (Bitnami)	`false`

Apollo Service

Deployment Configuration

Parameter	Description	Default
`apollo.replicaCount`	Number of Apollo replicas	`2`
`apollo.image.repository`	Apollo container image repository	ECR repository
`apollo.image.tag`	Apollo container image tag	`"0e07c93"`
`apollo.image.pullPolicy`	Image pull policy	`Always`

Service Configuration

Parameter	Description	Default
`apollo.service.type`	Kubernetes service type	`NodePort`
`apollo.service.port`	Service port	`9900`
`apollo.service.nodePort`	NodePort for external access	`30900`

Resource Limits

Parameter	Description	Default
`apollo.resources.requests.memory`	Memory request	`"5Gi"`
`apollo.resources.requests.cpu`	CPU request	`"1"`
`apollo.resources.limits.memory`	Memory limit	`"6Gi"`
`apollo.resources.limits.cpu`	CPU limit	`"1"`

Horizontal Pod Autoscaler (HPA)

Parameter	Description	Default
`apollo.autoscaling.enabled`	Enable HPA for Apollo	`false`
`apollo.autoscaling.minReplicas`	Minimum replicas	`2`
`apollo.autoscaling.maxReplicas`	Maximum replicas	`10`
`apollo.autoscaling.targetCPUUtilizationPercentage`	Target CPU for scaling	`70`
`apollo.autoscaling.targetMemoryUtilizationPercentage`	Target memory for scaling	`80`

Example: Enable HPA for Production:
                            apollo:
  replicaCount: 3
  autoscaling:
    enabled: true
    minReplicas: 3
    maxReplicas: 20
    targetCPUUtilizationPercentage: 70
    targetMemoryUtilizationPercentage: 80
                        

Thermos Service

Parameter	Description	Default
`thermos.replicaCount`	Number of Thermos replicas	`2`
`thermos.service.type`	Kubernetes service type	`ClusterIP`
`thermos.service.port`	Service port	`8180`
`thermos.resources.requests.memory`	Memory request	`"4Gi"`
`thermos.resources.requests.cpu`	CPU request	`"2"`
`thermos.autoscaling.enabled`	Enable HPA for Thermos	`false`

Mercury Service (Knative)

Deployment Configuration

Parameter	Description	Default
`mercury.enabled`	Deploy Mercury service	`true`
`mercury.useKnative`	Use Knative for serverless deployment	`true`
`mercury.replicaCount`	Initial replicas (if not Knative)	`1`

Auto-scaling Configuration

Parameter	Description	Default
`mercury.autoscaling.minScale`	Minimum Knative replicas	`1`
`mercury.autoscaling.maxScale`	Maximum Knative replicas	`10`
`mercury.autoscaling.target`	Target CPU utilization (%)	`80`
`mercury.containerConcurrency`	Max concurrent requests per container	`0` (unlimited)
`mercury.timeoutSeconds`	Request timeout in seconds	`300`

Example: Mercury with Scale-to-Zero:
                            mercury:
  enabled: true
  useKnative: true
  autoscaling:
    minScale: 0  # Scale to zero when idle
    maxScale: 20
    target: 80
  containerConcurrency: 100  # Limit concurrent requests
  timeoutSeconds: 600  # 10-minute timeout
                        

Temporal Workflow Engine

Parameter	Description	Default
`temporal.server.enabled`	Deploy Temporal server	`true`
`temporal.server.replicaCount`	Number of Temporal replicas	`2`
`temporal.web.enabled`	Deploy Temporal web UI	`true`
`temporal.schema.setup.enabled`	Auto-create database schema	`true`

Note: Temporal uses the external PostgreSQL database configured via secret-setup.sh. It automatically creates temporal and temporal_visibility databases.

Minio Object Storage

Parameter	Description	Default
`minio.replicaCount`	Number of Minio instances	`1`
`minio.auth.rootUser`	Minio admin username	`"minioadmin"`
`minio.auth.rootPassword`	Minio admin password	`"minioadmin123"`
`minio.persistence.enabled`	Enable persistent storage	`true`
`minio.persistence.size`	Persistent volume size	`8Gi`
`minio.persistence.storageClass`	Storage class for PVC	`""` (default)

Warning: Minio uses a RollingUpdate strategy with maxUnavailable=1 and maxSurge=0 to prevent Multi-Attach volume errors on single-replica deployments.

Redis Configuration

Parameter	Description	Default
`redis.enabled`	Deploy bundled Redis (Bitnami)	`false`
`externalRedis.enabled`	Use external Redis	`true`
`redis.auth.enabled`	Enable Redis authentication	`true`
`redis.auth.password`	Redis password (if bundled)	`"redis123"`
`redis.master.persistence.size`	Redis storage size (if bundled)	`8Gi`

Example: Use Bundled Redis:
                            externalRedis:
  enabled: false

redis:
  enabled: true
  auth:
    enabled: true
    password: "securepassword"
  master:
    persistence:
      enabled: true
      size: 16Gi
                        

OpenTelemetry & Observability

Core Configuration

Parameter	Description	Default
`otel.enabled`	Enable OpenTelemetry	`true`
`otel.traces.enabled`	Enable trace collection	`true`
`otel.metrics.enabled`	Enable metrics collection	`true`
`otel.environment`	Environment label	`"development"`

Collector Configuration

Parameter	Description	Default
`otel.collector.enabled`	Deploy OTEL collector	`true`
`otel.collector.replicaCount`	Number of collector instances	`1`
`otel.collector.googleCloud.enabled`	Export to Google Cloud	`true`
`otel.collector.googleCloud.projectId`	GCP project ID	`"self-host-kubernetes"`

Example: Disable Google Cloud Export:
                            otel:
  enabled: true
  collector:
    enabled: true
    googleCloud:
      enabled: false  # Only use local Prometheus
    config:
      exporters:
        prometheus:
          endpoint: "0.0.0.0:8889"
      service:
        pipelines:
          traces:
            exporters: [debug]
          metrics:
            exporters: [prometheus]
                        

Configuration Tips

Security Best Practices

Always use strong, auto-generated passwords in production
Enable external secrets management (AWS Secrets Manager, HashiCorp Vault)
Use TLS/SSL for all external database connections
Rotate ECR tokens regularly using automation
Apply network policies to restrict pod-to-pod communication

Performance Optimization

Enable HPA for production workloads
Use external managed databases (Cloud SQL, RDS) for better performance
Configure appropriate resource requests/limits based on load testing
Use node affinity to place services on appropriate node pools
Consider using Redis for caching to reduce database load

Cost Optimization

Use Mercury's scale-to-zero feature for dev/staging environments
Right-size resource requests after monitoring actual usage
Use spot/preemptible instances for non-critical workloads
Disable unused services (OTEL collector in dev, Temporal web UI)
Use shared managed services across multiple environments