add mintlify intro docs

2025-05-28 23:42:34 +05:30
parent b5ebc47637
commit f429db89b4
19 changed files with 10055 additions and 1 deletions
@@ -0,0 +1,745 @@
+---
+title: Google Cloud Platform (GCP) Deployment
+description: Deploy Chatwoot on Google Cloud Platform with Compute Engine, Cloud Run, or GKE
+sidebarTitle: GCP
+---
+
+# Google Cloud Platform Deployment Guide
+
+Deploy Chatwoot on Google Cloud Platform using Compute Engine, Cloud Run, or Google Kubernetes Engine for a scalable, enterprise-ready solution.
+
+## Deployment Options
+
+<CardGroup cols={3}>
+  <Card title="Compute Engine" icon="server" href="#compute-engine">
+    Traditional VM deployment with full control
+  </Card>
+  <Card title="Cloud Run" icon="cloud" href="#cloud-run">
+    Serverless container deployment
+  </Card>
+  <Card title="GKE" icon="kubernetes" href="#google-kubernetes-engine">
+    Managed Kubernetes deployment
+  </Card>
+</CardGroup>
+
+## Compute Engine Deployment
+
+### Prerequisites
+
+```bash
+# Install and configure gcloud CLI
+curl https://sdk.cloud.google.com | bash
+exec -l $SHELL
+gcloud init
+
+# Set project and region
+gcloud config set project your-project-id
+gcloud config set compute/region us-central1
+gcloud config set compute/zone us-central1-a
+```
+
+### Network Setup
+
+```bash
+# Create VPC network
+gcloud compute networks create chatwoot-vpc --subnet-mode=custom
+
+# Create subnet
+gcloud compute networks subnets create chatwoot-subnet \
+  --network=chatwoot-vpc \
+  --range=10.0.1.0/24 \
+  --region=us-central1
+
+# Create firewall rules
+gcloud compute firewall-rules create chatwoot-allow-http \
+  --network=chatwoot-vpc \
+  --allow=tcp:80,tcp:443,tcp:3000 \
+  --source-ranges=0.0.0.0/0 \
+  --target-tags=chatwoot-server
+
+gcloud compute firewall-rules create chatwoot-allow-ssh \
+  --network=chatwoot-vpc \
+  --allow=tcp:22 \
+  --source-ranges=0.0.0.0/0 \
+  --target-tags=chatwoot-server
+```
+
+### Database Setup
+
+#### Cloud SQL PostgreSQL
+
+```bash
+# Create Cloud SQL instance
+gcloud sql instances create chatwoot-db \
+  --database-version=POSTGRES_13 \
+  --tier=db-g1-small \
+  --region=us-central1 \
+  --storage-type=SSD \
+  --storage-size=100GB \
+  --storage-auto-increase \
+  --backup-start-time=03:00 \
+  --enable-bin-log \
+  --maintenance-window-day=SUN \
+  --maintenance-window-hour=04
+
+# Create database
+gcloud sql databases create chatwoot_production --instance=chatwoot-db
+
+# Create user
+gcloud sql users create chatwoot \
+  --instance=chatwoot-db \
+  --password=your-secure-password
+
+# Get connection name
+gcloud sql instances describe chatwoot-db --format="value(connectionName)"
+```
+
+#### Memorystore Redis
+
+```bash
+# Create Redis instance
+gcloud redis instances create chatwoot-redis \
+  --size=1 \
+  --region=us-central1 \
+  --redis-version=redis_6_x \
+  --network=chatwoot-vpc
+```
+
+### Storage Setup
+
+```bash
+# Create Cloud Storage bucket
+gsutil mb -p your-project-id -c STANDARD -l us-central1 gs://your-chatwoot-bucket
+
+# Set bucket permissions
+gsutil iam ch allUsers:objectViewer gs://your-chatwoot-bucket
+
+# Enable CORS
+cat > cors.json << EOF
+[
+  {
+    "origin": ["https://chatwoot.yourdomain.com"],
+    "method": ["GET", "PUT", "POST", "DELETE"],
+    "responseHeader": ["Content-Type"],
+    "maxAgeSeconds": 3600
+  }
+]
+EOF
+
+gsutil cors set cors.json gs://your-chatwoot-bucket
+```
+
+### Compute Instance
+
+#### Create Instance Template
+
+```bash
+# Create startup script
+cat > startup-script.sh << 'EOF'
+#!/bin/bash
+apt-get update
+apt-get install -y wget curl
+
+# Download and install Chatwoot
+wget https://get.chatwoot.app/linux/install.sh
+chmod +x install.sh
+./install.sh --install
+
+# Configure environment
+sudo -u chatwoot bash << 'INNER_EOF'
+cd /home/chatwoot/chatwoot
+cat > .env << 'ENV_EOF'
+RAILS_ENV=production
+NODE_ENV=production
+FRONTEND_URL=https://chatwoot.yourdomain.com
+FORCE_SSL=true
+
+# Database
+DATABASE_URL=postgresql://chatwoot:password@/chatwoot_production?host=/cloudsql/your-project:us-central1:chatwoot-db
+
+# Redis
+REDIS_URL=redis://10.0.0.3:6379/0
+
+# Storage
+ACTIVE_STORAGE_SERVICE=google
+GCS_PROJECT=your-project-id
+GCS_BUCKET=your-chatwoot-bucket
+
+# Email (using SendGrid)
+MAILER_SENDER_EMAIL=noreply@yourdomain.com
+SMTP_ADDRESS=smtp.sendgrid.net
+SMTP_PORT=587
+SMTP_USERNAME=apikey
+SMTP_PASSWORD=your-sendgrid-api-key
+SMTP_AUTHENTICATION=plain
+SMTP_ENABLE_STARTTLS_AUTO=true
+ENV_EOF
+
+# Prepare database
+RAILS_ENV=production bundle exec rake db:chatwoot_prepare
+INNER_EOF
+
+# Restart services
+systemctl restart chatwoot.target
+EOF
+
+# Create instance template
+gcloud compute instance-templates create chatwoot-template \
+  --machine-type=e2-standard-2 \
+  --network-interface=network=chatwoot-vpc,subnet=chatwoot-subnet \
+  --boot-disk-size=50GB \
+  --boot-disk-type=pd-ssd \
+  --image-family=ubuntu-2004-lts \
+  --image-project=ubuntu-os-cloud \
+  --tags=chatwoot-server \
+  --metadata-from-file startup-script=startup-script.sh \
+  --service-account=chatwoot-sa@your-project-id.iam.gserviceaccount.com \
+  --scopes=https://www.googleapis.com/auth/cloud-platform
+```
+
+#### Create Managed Instance Group
+
+```bash
+# Create instance group
+gcloud compute instance-groups managed create chatwoot-ig \
+  --template=chatwoot-template \
+  --size=2 \
+  --zone=us-central1-a
+
+# Configure autoscaling
+gcloud compute instance-groups managed set-autoscaling chatwoot-ig \
+  --max-num-replicas=5 \
+  --min-num-replicas=2 \
+  --target-cpu-utilization=0.7 \
+  --zone=us-central1-a
+```
+
+### Load Balancer
+
+```bash
+# Create health check
+gcloud compute health-checks create http chatwoot-health-check \
+  --port=3000 \
+  --request-path=/api
+
+# Create backend service
+gcloud compute backend-services create chatwoot-backend \
+  --protocol=HTTP \
+  --health-checks=chatwoot-health-check \
+  --global
+
+# Add instance group to backend service
+gcloud compute backend-services add-backend chatwoot-backend \
+  --instance-group=chatwoot-ig \
+  --instance-group-zone=us-central1-a \
+  --global
+
+# Create URL map
+gcloud compute url-maps create chatwoot-map \
+  --default-service=chatwoot-backend
+
+# Create SSL certificate
+gcloud compute ssl-certificates create chatwoot-ssl \
+  --domains=chatwoot.yourdomain.com
+
+# Create HTTPS proxy
+gcloud compute target-https-proxies create chatwoot-https-proxy \
+  --url-map=chatwoot-map \
+  --ssl-certificates=chatwoot-ssl
+
+# Create global forwarding rule
+gcloud compute forwarding-rules create chatwoot-https-rule \
+  --global \
+  --target-https-proxy=chatwoot-https-proxy \
+  --ports=443
+
+# Create HTTP to HTTPS redirect
+gcloud compute url-maps create chatwoot-redirect \
+  --default-url-redirect-response-code=301 \
+  --default-url-redirect-https-redirect
+
+gcloud compute target-http-proxies create chatwoot-http-proxy \
+  --url-map=chatwoot-redirect
+
+gcloud compute forwarding-rules create chatwoot-http-rule \
+  --global \
+  --target-http-proxy=chatwoot-http-proxy \
+  --ports=80
+```
+
+## Cloud Run Deployment
+
+### Containerize Chatwoot
+
+Create `Dockerfile`:
+
+```dockerfile
+FROM chatwoot/chatwoot:latest
+
+# Set environment variables
+ENV RAILS_ENV=production
+ENV NODE_ENV=production
+ENV PORT=8080
+
+# Expose port
+EXPOSE 8080
+
+# Start command
+CMD ["bundle", "exec", "rails", "server", "-b", "0.0.0.0", "-p", "8080"]
+```
+
+### Build and Deploy
+
+```bash
+# Build container image
+gcloud builds submit --tag gcr.io/your-project-id/chatwoot
+
+# Deploy to Cloud Run
+gcloud run deploy chatwoot \
+  --image gcr.io/your-project-id/chatwoot \
+  --platform managed \
+  --region us-central1 \
+  --allow-unauthenticated \
+  --memory 2Gi \
+  --cpu 2 \
+  --max-instances 10 \
+  --set-env-vars RAILS_ENV=production \
+  --set-env-vars DATABASE_URL="postgresql://..." \
+  --set-env-vars REDIS_URL="redis://..." \
+  --set-env-vars FRONTEND_URL="https://chatwoot.yourdomain.com"
+
+# Deploy worker service
+gcloud run deploy chatwoot-worker \
+  --image gcr.io/your-project-id/chatwoot \
+  --platform managed \
+  --region us-central1 \
+  --no-allow-unauthenticated \
+  --memory 1Gi \
+  --cpu 1 \
+  --max-instances 5 \
+  --command "bundle,exec,sidekiq,-C,config/sidekiq.yml" \
+  --set-env-vars RAILS_ENV=production \
+  --set-env-vars DATABASE_URL="postgresql://..." \
+  --set-env-vars REDIS_URL="redis://..."
+```
+
+### Custom Domain
+
+```bash
+# Map custom domain
+gcloud run domain-mappings create \
+  --service chatwoot \
+  --domain chatwoot.yourdomain.com \
+  --region us-central1
+```
+
+## Google Kubernetes Engine (GKE)
+
+### Create GKE Cluster
+
+```bash
+# Create GKE cluster
+gcloud container clusters create chatwoot-cluster \
+  --zone us-central1-a \
+  --num-nodes 3 \
+  --machine-type e2-standard-2 \
+  --disk-size 50GB \
+  --disk-type pd-ssd \
+  --enable-autoscaling \
+  --min-nodes 1 \
+  --max-nodes 5 \
+  --enable-autorepair \
+  --enable-autoupgrade \
+  --network chatwoot-vpc \
+  --subnetwork chatwoot-subnet
+
+# Get credentials
+gcloud container clusters get-credentials chatwoot-cluster --zone us-central1-a
+```
+
+### Helm Deployment
+
+```bash
+# Add Chatwoot Helm repository
+helm repo add chatwoot https://chatwoot.github.io/charts
+helm repo update
+
+# Create namespace
+kubectl create namespace chatwoot
+
+# Create values file for GCP
+cat > gcp-values.yaml << EOF
+# GCP-specific values
+ingress:
+  enabled: true
+  className: gce
+  annotations:
+    kubernetes.io/ingress.global-static-ip-name: "chatwoot-ip"
+    networking.gke.io/managed-certificates: "chatwoot-ssl"
+    kubernetes.io/ingress.allow-http: "false"
+  hosts:
+    - host: chatwoot.yourdomain.com
+      paths:
+        - path: /
+          pathType: Prefix
+
+# Use Cloud SQL and Memorystore
+postgresql:
+  enabled: false
+
+redis:
+  enabled: false
+
+env:
+  DATABASE_URL: "postgresql://chatwoot:password@/chatwoot_production?host=/cloudsql/your-project:us-central1:chatwoot-db"
+  REDIS_URL: "redis://10.0.0.3:6379/0"
+  ACTIVE_STORAGE_SERVICE: "google"
+  GCS_PROJECT: "your-project-id"
+  GCS_BUCKET: "your-chatwoot-bucket"
+
+# Resource limits
+resources:
+  limits:
+    cpu: 1000m
+    memory: 2Gi
+  requests:
+    cpu: 500m
+    memory: 1Gi
+
+# Workload Identity
+serviceAccount:
+  create: true
+  annotations:
+    iam.gke.io/gcp-service-account: chatwoot-sa@your-project-id.iam.gserviceaccount.com
+EOF
+
+# Install Chatwoot
+helm install chatwoot chatwoot/chatwoot \
+  --namespace chatwoot \
+  --values gcp-values.yaml
+```
+
+### SSL Certificate
+
+```yaml
+# managed-cert.yaml
+apiVersion: networking.gke.io/v1
+kind: ManagedCertificate
+metadata:
+  name: chatwoot-ssl
+  namespace: chatwoot
+spec:
+  domains:
+    - chatwoot.yourdomain.com
+```
+
+```bash
+kubectl apply -f managed-cert.yaml
+```
+
+## Service Account and IAM
+
+### Create Service Account
+
+```bash
+# Create service account
+gcloud iam service-accounts create chatwoot-sa \
+  --display-name="Chatwoot Service Account"
+
+# Grant necessary permissions
+gcloud projects add-iam-policy-binding your-project-id \
+  --member="serviceAccount:chatwoot-sa@your-project-id.iam.gserviceaccount.com" \
+  --role="roles/cloudsql.client"
+
+gcloud projects add-iam-policy-binding your-project-id \
+  --member="serviceAccount:chatwoot-sa@your-project-id.iam.gserviceaccount.com" \
+  --role="roles/storage.objectAdmin"
+
+gcloud projects add-iam-policy-binding your-project-id \
+  --member="serviceAccount:chatwoot-sa@your-project-id.iam.gserviceaccount.com" \
+  --role="roles/redis.editor"
+
+# Create and download key
+gcloud iam service-accounts keys create chatwoot-key.json \
+  --iam-account=chatwoot-sa@your-project-id.iam.gserviceaccount.com
+```
+
+## Monitoring and Logging
+
+### Cloud Monitoring
+
+```bash
+# Enable APIs
+gcloud services enable monitoring.googleapis.com
+gcloud services enable logging.googleapis.com
+
+# Create notification channel
+gcloud alpha monitoring channels create \
+  --display-name="Email Alerts" \
+  --type=email \
+  --channel-labels=email_address=admin@yourdomain.com
+```
+
+### Custom Metrics
+
+```yaml
+# monitoring.yaml
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: prometheus-config
+  namespace: chatwoot
+data:
+  prometheus.yml: |
+    global:
+      scrape_interval: 15s
+    scrape_configs:
+    - job_name: 'chatwoot'
+      static_configs:
+      - targets: ['chatwoot-service:3000']
+      metrics_path: /metrics
+```
+
+### Alerting Policies
+
+```bash
+# Create alerting policy for high CPU
+gcloud alpha monitoring policies create \
+  --policy-from-file=cpu-alert-policy.yaml
+
+# cpu-alert-policy.yaml
+cat > cpu-alert-policy.yaml << EOF
+displayName: "High CPU Usage"
+conditions:
+  - displayName: "CPU usage above 80%"
+    conditionThreshold:
+      filter: 'resource.type="gce_instance"'
+      comparison: COMPARISON_GREATER_THAN
+      thresholdValue: 0.8
+      duration: 300s
+combiner: OR
+enabled: true
+notificationChannels:
+  - projects/your-project-id/notificationChannels/CHANNEL_ID
+EOF
+```
+
+## Backup and Disaster Recovery
+
+### Database Backups
+
+```bash
+# Cloud SQL automatic backups are enabled by default
+# Create on-demand backup
+gcloud sql backups create --instance=chatwoot-db
+
+# List backups
+gcloud sql backups list --instance=chatwoot-db
+
+# Restore from backup
+gcloud sql backups restore BACKUP_ID --restore-instance=chatwoot-db-restore
+```
+
+### Application Backups
+
+```bash
+#!/bin/bash
+# backup-script.sh
+DATE=$(date +%Y%m%d_%H%M%S)
+
+# Database backup
+gcloud sql export sql chatwoot-db gs://your-backup-bucket/db/chatwoot_$DATE.sql
+
+# File storage backup
+gsutil -m rsync -r -d gs://your-chatwoot-bucket gs://your-backup-bucket/files/
+
+# Kubernetes configuration backup
+kubectl get all -n chatwoot -o yaml > k8s-backup-$DATE.yaml
+gsutil cp k8s-backup-$DATE.yaml gs://your-backup-bucket/k8s/
+```
+
+## Security Best Practices
+
+### Network Security
+
+```bash
+# Create private cluster
+gcloud container clusters create chatwoot-private \
+  --enable-private-nodes \
+  --master-ipv4-cidr-block 172.16.0.0/28 \
+  --enable-ip-alias \
+  --enable-network-policy
+
+# Create firewall rules for private access
+gcloud compute firewall-rules create allow-chatwoot-private \
+  --network chatwoot-vpc \
+  --allow tcp:443,tcp:80 \
+  --source-ranges 10.0.0.0/8
+```
+
+### Secret Management
+
+```bash
+# Create secrets in Secret Manager
+gcloud secrets create database-password --data-file=db-password.txt
+gcloud secrets create redis-password --data-file=redis-password.txt
+
+# Grant access to service account
+gcloud secrets add-iam-policy-binding database-password \
+  --member="serviceAccount:chatwoot-sa@your-project-id.iam.gserviceaccount.com" \
+  --role="roles/secretmanager.secretAccessor"
+```
+
+### Binary Authorization
+
+```bash
+# Enable Binary Authorization
+gcloud container binauthz policy import policy.yaml
+
+# policy.yaml
+cat > policy.yaml << EOF
+defaultAdmissionRule:
+  requireAttestationsBy:
+  - projects/your-project-id/attestors/prod-attestor
+  enforcementMode: ENFORCED_BLOCK_AND_AUDIT_LOG
+globalPolicyEvaluationMode: ENABLE
+EOF
+```
+
+## Cost Optimization
+
+### Preemptible Instances
+
+```bash
+# Create preemptible node pool
+gcloud container node-pools create preemptible-pool \
+  --cluster=chatwoot-cluster \
+  --zone=us-central1-a \
+  --machine-type=e2-standard-2 \
+  --preemptible \
+  --num-nodes=2 \
+  --enable-autoscaling \
+  --min-nodes=0 \
+  --max-nodes=5
+```
+
+### Committed Use Discounts
+
+```bash
+# Purchase committed use discount
+gcloud compute commitments create chatwoot-commitment \
+  --plan=12-month \
+  --region=us-central1 \
+  --resources=type=VCPU,amount=4 \
+  --resources=type=MEMORY,amount=16
+```
+
+### Resource Optimization
+
+```yaml
+# resource-quota.yaml
+apiVersion: v1
+kind: ResourceQuota
+metadata:
+  name: chatwoot-quota
+  namespace: chatwoot
+spec:
+  hard:
+    requests.cpu: "4"
+    requests.memory: 8Gi
+    limits.cpu: "8"
+    limits.memory: 16Gi
+    persistentvolumeclaims: "4"
+```
+
+## Troubleshooting
+
+### Common Issues
+
+<Accordion title="Cloud SQL connection issues">
+Check:
+- Cloud SQL Proxy configuration
+- Service account permissions
+- Network connectivity
+- SSL requirements
+</Accordion>
+
+<Accordion title="GKE pod startup failures">
+Verify:
+- Resource quotas and limits
+- Image pull permissions
+- Service account configuration
+- Network policies
+</Accordion>
+
+<Accordion title="Load balancer health check failures">
+Solutions:
+- Verify health check path (/api)
+- Check firewall rules
+- Ensure proper backend configuration
+- Review application startup time
+</Accordion>
+
+### Diagnostic Commands
+
+```bash
+# Check Compute Engine instances
+gcloud compute instances list
+
+# View Cloud Run services
+gcloud run services list
+
+# Check GKE cluster status
+gcloud container clusters describe chatwoot-cluster --zone us-central1-a
+
+# View logs
+gcloud logging read "resource.type=gce_instance" --limit 50
+gcloud logging read "resource.type=cloud_run_revision" --limit 50
+
+# Check Cloud SQL status
+gcloud sql instances describe chatwoot-db
+```
+
+### Performance Monitoring
+
+```bash
+# View metrics
+gcloud monitoring metrics list --filter="metric.type:compute"
+
+# Create dashboard
+gcloud monitoring dashboards create --config-from-file=dashboard.json
+```
+
+## Best Practices
+
+### Security
+- Use private GKE clusters
+- Enable Workload Identity
+- Implement Binary Authorization
+- Use Secret Manager for sensitive data
+- Enable audit logging
+
+### Performance
+- Use Cloud CDN for static assets
+- Implement Cloud Memorystore for caching
+- Use SSD persistent disks
+- Enable HTTP/2 and gRPC
+- Optimize container images
+
+### Reliability
+- Deploy across multiple zones
+- Use managed services (Cloud SQL, Memorystore)
+- Implement proper health checks
+- Set up monitoring and alerting
+- Test disaster recovery procedures
+
+### Cost Management
+- Use preemptible instances for non-critical workloads
+- Implement resource quotas
+- Purchase committed use discounts
+- Monitor usage with Cloud Billing
+- Use Cloud Functions for event-driven tasks
+
+---
+
+This GCP deployment guide provides comprehensive options for hosting Chatwoot on Google Cloud Platform. Choose the deployment method that best aligns with your scalability, security, and operational requirements.