Cloud Provider Deployment Guides

Step-by-step guides for deploying Composio on major cloud platforms

Google GKE

Google Kubernetes Engine

Amazon EKS

Elastic Kubernetes Service

Azure AKS

Azure Kubernetes Service

Google Kubernetes Engine (GKE)

Prerequisites

Google Cloud account with billing enabled
gcloud CLI installed and configured
kubectl installed
Helm 3.x installed

Step 1: Set Up Environment Variables

# Set your project variables
export PROJECT_ID="your-gcp-project-id"
export REGION="us-central1"
export CLUSTER_NAME="composio-cluster"
export ZONE="us-central1-a"

# Set project
gcloud config set project $PROJECT_ID

Step 2: Create GKE Cluster

Option A: GKE Autopilot (Recommended)

# Create Autopilot cluster (fully managed)
gcloud container clusters create-auto $CLUSTER_NAME \
    --region=$REGION \
    --project=$PROJECT_ID

# Get credentials
gcloud container clusters get-credentials $CLUSTER_NAME \
    --region=$REGION \
    --project=$PROJECT_ID

Option B: Standard GKE Cluster

# Create standard cluster with custom configuration
gcloud container clusters create $CLUSTER_NAME \
    --region=$REGION \
    --num-nodes=3 \
    --machine-type=n2-standard-8 \
    --disk-size=50GB \
    --enable-autoscaling \
    --min-nodes=3 \
    --max-nodes=10 \
    --enable-autorepair \
    --enable-autoupgrade \
    --project=$PROJECT_ID

# Get credentials
gcloud container clusters get-credentials $CLUSTER_NAME \
    --region=$REGION \
    --project=$PROJECT_ID

Step 3: Create Cloud SQL PostgreSQL Instance

# Create PostgreSQL instance
gcloud sql instances create composio-postgres \
    --database-version=POSTGRES_15 \
    --tier=db-custom-4-16384 \
    --region=$REGION \
    --network=default \
    --no-assign-ip

# Set root password
gcloud sql users set-password postgres \
    --instance=composio-postgres \
    --password="YourSecurePassword123!"

# Create database
gcloud sql databases create composio \
    --instance=composio-postgres

# Get connection info
export POSTGRES_IP=$(gcloud sql instances describe composio-postgres \
    --format='get(ipAddresses[0].ipAddress)')
export POSTGRES_URL="postgresql://postgres:YourSecurePassword123!@${POSTGRES_IP}:5432/composio?sslmode=require"

Step 4: Set Up Workload Identity (Optional but Recommended)

# Create service account for OTEL collector
gcloud iam service-accounts create otel-collector \
    --display-name="OpenTelemetry Collector"

# Grant permissions
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="serviceAccount:otel-collector@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/cloudtrace.agent"

gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="serviceAccount:otel-collector@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/monitoring.metricWriter"

Step 5: Install Knative on GKE

# Install Knative Serving CRDs
kubectl apply -f https://github.com/knative/serving/releases/download/knative-v1.15.0/serving-crds.yaml

# Install Knative Serving Core
kubectl apply -f https://github.com/knative/serving/releases/download/knative-v1.15.0/serving-core.yaml

# Install Kourier for networking
kubectl apply -f https://github.com/knative/net-kourier/releases/download/knative-v1.15.0/kourier.yaml

# Configure Kourier as default
kubectl patch configmap/config-network \
    --namespace knative-serving \
    --type merge \
    --patch '{"data":{"ingress-class":"kourier.ingress.networking.knative.dev"}}'

# Wait for Knative to be ready
kubectl wait --for=condition=Ready pods --all -n knative-serving --timeout=300s

Step 6: Configure Secrets

# Export required secrets
export POSTGRES_URL="postgresql://postgres:YourSecurePassword123!@${POSTGRES_IP}:5432/composio?sslmode=require"
export REDIS_URL=""  # Leave empty to use bundled Redis
export OPENAI_API_KEY="sk-your-openai-key"  # Optional

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

Step 7: Deploy Composio

# Deploy with Helm
helm install composio ./composio \
    --create-namespace \
    --namespace composio \
    --set namespace.name=composio \
    --set externalSecrets.ecr.token="$(aws ecr get-login-password --region us-east-1)" \
    --set otel.collector.googleCloud.projectId=$PROJECT_ID \
    --debug

# Wait for deployment
kubectl wait --for=condition=Ready pods --all -n composio --timeout=600s

Step 8: Verify Installation

# Check all pods
kubectl get pods -n composio

# Check Knative services
kubectl get ksvc -n composio

# Port forward to Apollo
kubectl port-forward -n composio svc/composio-apollo 8080:9900

# Test API
curl http://localhost:8080/api/v1/health

GKE Autopilot Tips:

Autopilot automatically manages node provisioning and scaling
Resource requests are strictly enforced - ensure proper values
Some features like privileged containers are disabled
Cost is based on pod resource requests, not node size

Amazon Elastic Kubernetes Service (EKS)

Prerequisites

AWS account with appropriate IAM permissions
AWS CLI installed and configured
eksctl installed
kubectl installed
Helm 3.x installed

Step 1: Set Up Environment Variables

# Set your AWS variables
export AWS_REGION="us-east-1"
export CLUSTER_NAME="composio-eks-cluster"
export AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)

Step 2: Create EKS Cluster

# Create EKS cluster using eksctl
eksctl create cluster \
    --name $CLUSTER_NAME \
    --region $AWS_REGION \
    --version 1.28 \
    --nodegroup-name standard-workers \
    --node-type t3.2xlarge \
    --nodes 3 \
    --nodes-min 3 \
    --nodes-max 10 \
    --managed \
    --with-oidc \
    --ssh-access \
    --ssh-public-key ~/.ssh/id_rsa.pub

# Update kubeconfig
aws eks update-kubeconfig \
    --region $AWS_REGION \
    --name $CLUSTER_NAME

Step 3: Create RDS PostgreSQL Database

# Create DB subnet group
aws rds create-db-subnet-group \
    --db-subnet-group-name composio-db-subnet \
    --db-subnet-group-description "Composio Database Subnet" \
    --subnet-ids subnet-xxx subnet-yyy \
    --region $AWS_REGION

# Create PostgreSQL instance
aws rds create-db-instance \
    --db-instance-identifier composio-postgres \
    --db-instance-class db.t3.large \
    --engine postgres \
    --engine-version 15.4 \
    --master-username postgres \
    --master-user-password "YourSecurePassword123!" \
    --allocated-storage 100 \
    --storage-type gp3 \
    --vpc-security-group-ids sg-xxx \
    --db-subnet-group-name composio-db-subnet \
    --backup-retention-period 7 \
    --region $AWS_REGION

# Wait for instance to be available
aws rds wait db-instance-available \
    --db-instance-identifier composio-postgres

# Get endpoint
export DB_ENDPOINT=$(aws rds describe-db-instances \
    --db-instance-identifier composio-postgres \
    --query 'DBInstances[0].Endpoint.Address' \
    --output text)

export POSTGRES_URL="postgresql://postgres:YourSecurePassword123!@${DB_ENDPOINT}:5432/postgres?sslmode=require"

Step 4: Create ElastiCache Redis (Optional)

# Create Redis cluster
aws elasticache create-cache-cluster \
    --cache-cluster-id composio-redis \
    --cache-node-type cache.t3.medium \
    --engine redis \
    --num-cache-nodes 1 \
    --security-group-ids sg-xxx \
    --region $AWS_REGION

# Get Redis endpoint
export REDIS_ENDPOINT=$(aws elasticache describe-cache-clusters \
    --cache-cluster-id composio-redis \
    --show-cache-node-info \
    --query 'CacheClusters[0].CacheNodes[0].Endpoint.Address' \
    --output text)

export REDIS_URL="redis://${REDIS_ENDPOINT}:6379/0"

Step 5: Install AWS Load Balancer Controller

# Create IAM policy
curl -o iam_policy.json https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.6.0/docs/install/iam_policy.json

aws iam create-policy \
    --policy-name AWSLoadBalancerControllerIAMPolicy \
    --policy-document file://iam_policy.json

# Create service account
eksctl create iamserviceaccount \
    --cluster=$CLUSTER_NAME \
    --namespace=kube-system \
    --name=aws-load-balancer-controller \
    --attach-policy-arn=arn:aws:iam::${AWS_ACCOUNT_ID}:policy/AWSLoadBalancerControllerIAMPolicy \
    --override-existing-serviceaccounts \
    --approve

# Install controller via Helm
helm repo add eks https://aws.github.io/eks-charts
helm repo update

helm install aws-load-balancer-controller eks/aws-load-balancer-controller \
    -n kube-system \
    --set clusterName=$CLUSTER_NAME \
    --set serviceAccount.create=false \
    --set serviceAccount.name=aws-load-balancer-controller

Step 6: Install Knative on EKS

# Install Knative Serving
kubectl apply -f https://github.com/knative/serving/releases/download/knative-v1.15.0/serving-crds.yaml
kubectl apply -f https://github.com/knative/serving/releases/download/knative-v1.15.0/serving-core.yaml

# Install Kourier
kubectl apply -f https://github.com/knative/net-kourier/releases/download/knative-v1.15.0/kourier.yaml

# Configure Kourier
kubectl patch configmap/config-network \
    --namespace knative-serving \
    --type merge \
    --patch '{"data":{"ingress-class":"kourier.ingress.networking.knative.dev"}}'

Step 7: Configure Secrets & Deploy

# Set secrets
export POSTGRES_URL="postgresql://postgres:YourSecurePassword123!@${DB_ENDPOINT}:5432/postgres?sslmode=require"
export REDIS_URL="redis://${REDIS_ENDPOINT}:6379/0"

./secret-setup.sh -r composio -n composio

# Deploy Composio
helm install composio ./composio \
    --create-namespace \
    --namespace composio \
    --set namespace.name=composio \
    --set externalSecrets.ecr.token="$(aws ecr get-login-password --region $AWS_REGION)" \
    --debug

EKS Security Tips:

Use VPC security groups to control database access
Enable encryption at rest for RDS and ElastiCache
Use AWS Secrets Manager for production credentials
Enable EKS cluster logging for audit trails

Azure Kubernetes Service (AKS)

Prerequisites

Azure account with active subscription
Azure CLI (az) installed and configured
kubectl installed
Helm 3.x installed

Step 1: Set Up Environment Variables

# Set Azure variables
export RESOURCE_GROUP="composio-rg"
export LOCATION="eastus"
export CLUSTER_NAME="composio-aks-cluster"
export ACR_NAME="composioacr"

# Login to Azure
az login
az account set --subscription "Your-Subscription-Name"

Step 2: Create Resource Group

# Create resource group
az group create \
    --name $RESOURCE_GROUP \
    --location $LOCATION

Step 3: Create AKS Cluster

# Create AKS cluster
az aks create \
    --resource-group $RESOURCE_GROUP \
    --name $CLUSTER_NAME \
    --node-count 3 \
    --node-vm-size Standard_D8s_v3 \
    --enable-managed-identity \
    --enable-addons monitoring \
    --enable-cluster-autoscaler \
    --min-count 3 \
    --max-count 10 \
    --generate-ssh-keys

# Get credentials
az aks get-credentials \
    --resource-group $RESOURCE_GROUP \
    --name $CLUSTER_NAME

Step 4: Create Azure Database for PostgreSQL

# Create PostgreSQL server
az postgres flexible-server create \
    --resource-group $RESOURCE_GROUP \
    --name composio-postgres \
    --location $LOCATION \
    --admin-user adminuser \
    --admin-password "YourSecurePassword123!" \
    --sku-name Standard_D4s_v3 \
    --tier GeneralPurpose \
    --storage-size 128 \
    --version 15

# Create database
az postgres flexible-server db create \
    --resource-group $RESOURCE_GROUP \
    --server-name composio-postgres \
    --database-name composio

# Get connection string
export POSTGRES_HOST=$(az postgres flexible-server show \
    --resource-group $RESOURCE_GROUP \
    --name composio-postgres \
    --query "fullyQualifiedDomainName" -o tsv)

export POSTGRES_URL="postgresql://adminuser:YourSecurePassword123!@${POSTGRES_HOST}:5432/composio?sslmode=require"

Step 5: Create Azure Cache for Redis (Optional)

# Create Redis cache
az redis create \
    --resource-group $RESOURCE_GROUP \
    --name composio-redis \
    --location $LOCATION \
    --sku Standard \
    --vm-size c1

# Get Redis connection info
export REDIS_HOST=$(az redis show \
    --resource-group $RESOURCE_GROUP \
    --name composio-redis \
    --query "hostName" -o tsv)

export REDIS_KEY=$(az redis list-keys \
    --resource-group $RESOURCE_GROUP \
    --name composio-redis \
    --query "primaryKey" -o tsv)

export REDIS_URL="redis://:${REDIS_KEY}@${REDIS_HOST}:6380/0?ssl=true"

Step 6: Install Knative on AKS

# Install Knative Serving
kubectl apply -f https://github.com/knative/serving/releases/download/knative-v1.15.0/serving-crds.yaml
kubectl apply -f https://github.com/knative/serving/releases/download/knative-v1.15.0/serving-core.yaml

# Install Kourier
kubectl apply -f https://github.com/knative/net-kourier/releases/download/knative-v1.15.0/kourier.yaml

# Configure Kourier
kubectl patch configmap/config-network \
    --namespace knative-serving \
    --type merge \
    --patch '{"data":{"ingress-class":"kourier.ingress.networking.knative.dev"}}'

Step 7: Configure Secrets & Deploy

# Set secrets
export POSTGRES_URL="postgresql://adminuser:YourSecurePassword123!@${POSTGRES_HOST}:5432/composio?sslmode=require"
export REDIS_URL="redis://:${REDIS_KEY}@${REDIS_HOST}:6380/0?ssl=true"

./secret-setup.sh -r composio -n composio

# Deploy Composio
helm install composio ./composio \
    --create-namespace \
    --namespace composio \
    --set namespace.name=composio \
    --set externalSecrets.ecr.token="$(aws ecr get-login-password --region us-east-1)" \
    --debug

AKS Tips:

Use Azure Monitor for container insights
Enable Azure Active Directory integration for RBAC
Use Azure Key Vault for secrets management
Consider using Azure Application Gateway for ingress

Cloud Provider Comparison

Feature	GKE	EKS	AKS
Managed Control Plane	Yes	Yes	Yes
Autopilot Mode	Yes	No	No
Integrated Database	Cloud SQL	RDS	Azure Database
Integrated Redis	Memorystore	ElastiCache	Azure Cache
Native Monitoring	Cloud Monitoring	CloudWatch	Azure Monitor
Setup Complexity	Low	Medium	Medium
Cost (Relative)	$$	$$	$$