Back to integrations

Integrate Google App Engine with Strapi

Google App Engine lets app developers build scalable web and mobile back ends in any programming language on a fully managed serverless platform.

tweet selection

    These integration guides are not official documentation and the Strapi Support Team will not provide assistance with them.

    What Is Google App Engine?

    Google App Engine is a managed Platform-as-a-Service (PaaS) that runs your Node.js applications without requiring you to manage infrastructure. When your traffic spikes, new instances spawn automatically. When demand decreases, instances terminate to reduce costs.

    App Engine offers two environment types: Standard and Flexible. For Strapi deployments, the Standard environment provides critical advantages: the ability to scale to zero instances during periods without traffic, which eliminates costs when traffic is absent. This contrasts with the Flexible environment, which requires at least one instance running continuously.

    The platform integrates directly with other Google Cloud services like Cloud SQL for databases, Cloud Storage for media files, and Secret Manager for credential management. Deploy with a single command (gcloud app deploy) rather than multi-step deployment scripts. The automatic scaling configuration adjusts instance counts based on CPU utilization and request throughput.

    App Engine bills by instance class (such as B1, B2, B4) with a free tier that applies to all standard environment usage.

    Why Integrate Google App Engine with Strapi?

    The combination of App Engine's managed infrastructure with Strapi's headless CMS capabilities addresses several pain points you face when deploying full-stack applications to production.

    Operational Simplicity Without Sacrificing Control

    App Engine eliminates the server maintenance treadmill entirely:

    • No more SSH access, OS updates, or patch management required
    • Configure scaling thresholds in app.yaml, and App Engine manages instance lifecycle from there
    • Unix socket connections bypass TCP/IP overhead for optimized database performance

    Automatic Scaling That Actually Works

    App Engine handles instance management based on your configured thresholds:

    • Configure target CPU utilization and maximum concurrent requests per instance
    • New instances spawn automatically when traffic spikes
    • Instances terminate when demand decreases to reduce costs (instance management)

    Integrated Google Cloud Ecosystem

    If your organization already uses Google Cloud Platform services, App Engine fits naturally into existing workflows:

    • Cloud Build handles CI/CD pipelines
    • Cloud Storage manages media files with global distribution
    • IAM-based security eliminates manual credential management
    • Service-to-service authentication can leverage Application Default Credentials on App Engine, but additional IAM and token configuration is required for secure communication between services

    Cost Considerations

    App Engine can cost approximately $160–$290/month for compute infrastructure (2 vCPU, 4GB RAM equivalent), depending on usage, region, and instance class. This trades higher compute cost for zero-configuration management: eliminating weekend server maintenance and midnight security patches.

    When This Integration Makes Sense

    This integration works best for teams already using Google Cloud Platform services, projects requiring automatic scaling without DevOps investment, or organizations prioritizing operational simplicity over cost optimization.

    How to Integrate Google App Engine with Strapi

    Configure this integration in five steps that build upon each other sequentially. Start by installing prerequisites and the Google Cloud CLI, then prepare your Strapi project structure with the correct dependencies. Next, configure the app.yaml deployment descriptor, establish Cloud SQL database connectivity using Unix sockets, and implement Secret Manager for credential security.

    Prerequisites

    Before starting, verify you have Node.js v18 or v20 LTS installed locally. Strapi v4+ requires Node.js v18 or v20 (Active or Maintenance LTS versions only) (installation prerequisites). App Engine Standard supports Node.js v18 and v20, with either version providing strong compatibility for Strapi v4 (runtime documentation).

    Install the Google Cloud CLI to manage deployments:

    1# macOS (using Homebrew)
2brew install --cask google-cloud-sdk
3gcloud init
4
5# Linux (Debian/Ubuntu)
6sudo apt-get install google-cloud-sdk
7gcloud init

    Authenticate and configure your project:

    1gcloud auth login
2gcloud config set project YOUR_PROJECT_ID
3gcloud app create --region=us-central1

    Enable required APIs:

    1gcloud services enable appengine.googleapis.com
2gcloud services enable cloudbuild.googleapis.com
3gcloud services enable sqladmin.googleapis.com
4gcloud services enable storage.googleapis.com
5gcloud services enable secretmanager.googleapis.com

    App Engine requires billing enabled: create and link a billing account in Cloud Console.

    Preparing Your Strapi Project for Deployment

    Install the Google Cloud Storage provider:

    1npm install @strapi-community/strapi-provider-upload-google-cloud-storage

    Add the gcp-build script to your package.json:

    1{
2  "scripts": {
3    "develop": "strapi develop",
4    "start": "strapi start",
5    "build": "strapi build",
6    "gcp-build": "strapi build"
7  }
8}

    App Engine automatically executes gcp-build during deployment to rebuild your admin panel.

    Add a .gcloudignore file in your project root:

    1.git
2node_modules/
3.env
4.cache/
5build/
6.tmp/

    Set up your production server settings in config/env/production/server.js:

    1module.exports = {
2  host: '0.0.0.0',
3  port: process.env.PORT || 8080,
4  admin: {
5    path: '/admin',
6  },
7};

    Configuring app.yaml for Strapi

    The app.yaml file defines your runtime environment, instance specifications, and scaling behavior. Place this file in your project root:

    1runtime: nodejs18
2instance_class: F2
3
4env_variables:
5  NODE_ENV: production
6  HOST: 0.0.0.0
7  PORT: 8080
8  DATABASE_HOST: /cloudsql/PROJECT_ID:REGION:INSTANCE_NAME
9  DATABASE_NAME: strapi_db
10  DATABASE_USERNAME: strapi_user
11  GCS_BUCKET_NAME: your-bucket-name
12
13automatic_scaling:
14  min_instances: 1
15  max_instances: 5
16  target_cpu_utilization: 0.6
17  max_concurrent_requests: 50
18
19beta_settings:
20  cloud_sql_instances: PROJECT_ID:REGION:INSTANCE_NAME

    Set min_instances: 1 to eliminate cold starts, though this means paying for that instance running 24/7. For development environments where you don't mind waiting 10-30 seconds for the first request, use 0. The max_instances: 10 setting prevents unbounded scaling during traffic spikes. Setting target_cpu_utilization: 0.65 triggers scaling when CPU reaches 65%).

    Never hardcode sensitive credentials like database passwords in app.yaml. Deployment logs expose these values in plain text. Store sensitive values in Google Cloud Secret Manager instead.

    Setting Up Cloud SQL as Your Database

    Cloud SQL provides managed PostgreSQL (v14+) or MySQL (v8.0+) databases with automatic backups and high availability. Set up a PostgreSQL instance:

    1gcloud sql instances create strapi-db \
2  --database-version=POSTGRES_17 \
3  --tier=db-f1-micro \
4  --region=us-central1 \
5  --backup-start-time=02:00

    The db-f1-micro tier works for development; benchmark query performance before production.

    Create your database and user:

    1gcloud sql databases create strapi_db --instance=strapi-db
2
3gcloud sql users create strapi_user \
4  --instance=strapi-db \
5  --password=YOUR_SECURE_PASSWORD

    App Engine Standard supports connecting to Cloud SQL using both Unix sockets (for the built‑in integration) and TCP/IP (via the Cloud SQL Auth Proxy or VPC connector), depending on your runtime and configuration. Add config/env/production/database.js:

    1module.exports = ({ env }) => ({
2  connection: {
3    client: 'postgres',
4    connection: {
5      host: `/cloudsql/${env('INSTANCE_CONNECTION_NAME')}`,
6      port: 5432,
7      database: env('DATABASE_NAME'),
8      user: env('DATABASE_USERNAME'),
9      password: env('DATABASE_PASSWORD'),
10      ssl: false,
11    },
12    pool: {
13      min: 2,
14      max: 10,
15      acquireTimeoutMillis: 30000,
16      idleTimeoutMillis: 30000,
17    },
18  },
19});

    The Unix socket path format (/cloudsql/PROJECT_ID:REGION:INSTANCE_NAME) is required. The Cloud SQL Proxy connection via Unix socket handles encryption automatically.

    Grant the App Engine service account the Cloud SQL Client role, following the instructions in the IAM documentation for assigning roles to service accounts.

    Managing Environment Variables with Secret Manager

    Secret Manager provides encrypted credential storage with fine-grained access control.

    Store secrets for sensitive values:

    1# Generate secure random secret
2node -p "require('crypto').randomBytes(16).toString('base64')"
3
4# Store database password
5echo -n "your-actual-password" | gcloud secrets create strapi-db-password --data-file=-
6
7# Store JWT secret
8openssl rand -base64 32 | gcloud secrets create strapi-jwt-secret --data-file=-

    Grant your App Engine service account access:

    1PROJECT_ID=$(gcloud config get-value project)
2SERVICE_ACCOUNT="${PROJECT_ID}@appspot.gserviceaccount.com"
3
4gcloud secrets add-iam-policy-binding strapi-db-password \
5  --member="serviceAccount:${SERVICE_ACCOUNT}" \
6  --role="roles/secretmanager.secretAccessor"

    Add the Secret Manager client library:

    1npm install @google-cloud/secret-manager

    Create a utility module (utils/secrets.js) that fetches and caches secrets from Google Secret Manager (consider adding a TTL-based cache to support secret rotation):

    1const { SecretManagerServiceClient } = require('@google-cloud/secret-manager');
2const client = new SecretManagerServiceClient();
3
4const secretCache = new Map();
5
6async function accessSecret(secretName) {
7  if (secretCache.has(secretName)) {
8    return secretCache.get(secretName);
9  }
10
11  const projectId = process.env.GOOGLE_CLOUD_PROJECT;
12  const name = `projects/${projectId}/secrets/${secretName}/versions/latest`;
13
14  try {
15    const [version] = await client.accessSecretVersion({ name });
16    const secretValue = version.payload.data.toString('utf8');
17    
18    secretCache.set(secretName, secretValue);
19    return secretValue;
20  } catch (error) {
21    console.error(`Error accessing secret ${secretName}:`, error);
22    throw error;
23  }
24}
25
26module.exports = { accessSecret };

    The following pattern ensures secrets are loaded asynchronously before application startup, but does not by itself guarantee secure loading from Google Secret Manager or full alignment with Google Cloud's recommended security practices:

    1const { accessSecret } = require('./utils/secrets');
2
3async function loadSecrets() {
4  process.env.DATABASE_PASSWORD = await accessSecret('strapi-db-password');
5  process.env.JWT_SECRET = await accessSecret('strapi-jwt-secret');
6  process.env.API_KEY = await accessSecret('strapi-api-key');
7}
8
9loadSecrets().then(() => {
10  require('./src/index');
11}).catch(err => {
12  console.error('Failed to load secrets:', err);
13  process.exit(1);
14});

    This keeps credentials out of source control and deployment logs (Secret Manager practices).

    Deploying and Scaling Your Strapi Instance

    Deploy your application with a single command:

    1gcloud app deploy

    This command uploads your source files, installs dependencies in the cloud environment, executes your build script, and routes traffic to the new version.

    Access your deployed application:

    1gcloud app browse

    Monitor real-time logs:

    1gcloud app logs tail

    The automatic scaling configuration in your app.yaml manages instance counts based on your specified thresholds. When CPU utilization or concurrent requests per instance exceed the targets you define, App Engine automatically spawns additional instances. When traffic decreases, excess instances are terminated.

    The Cloud Console dashboard shows real-time scaling activity, CPU utilization, and memory consumption to help optimize these thresholds.

    For traffic splitting during A/B testing or gradual rollouts, route traffic across versions using gcloud app services set-traffic default --splits v1=0.7,v2=0.3 --split-by ip for consistent user experiences.

    Project Example: Build a Scalable Media Library API with Google App Engine and Strapi

    A media library API exercises every critical component of this integration: database persistence, Cloud Storage, automatic scaling, and content delivery optimization. This example builds an API managing images, videos, and documents with categorization, metadata, and public access controls.

    The architecture combines Cloud SQL PostgreSQL for content type schemas and relationships with Google Cloud Storage for file storage. App Engine's automatic scaling handles variable traffic patterns automatically. The admin panel provides content management while REST and GraphQL APIs enable frontend consumption.

    This pattern adapts well to digital asset management systems, documentation platforms, portfolio sites, and other applications that need scalable media handling. The configuration adjusts to traffic patterns automatically. A documentation site might serve steady baseline traffic with occasional spikes when new features launch, while a portfolio site might experience unpredictable viral traffic.

    This separation of concerns (metadata in Cloud SQL, media in Cloud Storage) provides independent scaling for each component. The Cloud Storage integration eliminates filesystem constraints inherent to App Engine's read-only environment, enabling unlimited media storage without affecting application instance performance.

    Google Cloud Storage's global network provides low-latency access, enabling everything from marketing websites to mobile applications.

    Step 1: Configure Strapi Media Handling for Cloud Storage

    Start by installing the Cloud Storage provider:

    1npm install @strapi-community/strapi-provider-upload-google-cloud-storage

    Next, create config/plugins.js:

    1module.exports = ({ env }) => ({
2  upload: {
3    config: {
4      provider: '@strapi-community/strapi-provider-upload-google-cloud-storage',
5      providerOptions: {
6        bucketName: env('GCS_BUCKET_NAME'),
7        publicFiles: env.bool('GCS_PUBLIC_FILES', true),
8        uniform: env.bool('GCS_UNIFORM', false),
9        basePath: '',
10        serviceAccount: env.json('GCS_SERVICE_ACCOUNT'),
11      },
12    },
13  },
14});

    Set up your Cloud Storage bucket with:

    1gcloud storage buckets create gs://your-media-bucket --location=us-central1

    Then, create a service account in the Google Cloud Console, give it the 'Storage Object Admin' role on the bucket, download the service account JSON, and set the following environment variables:

    1GCS_BUCKET_NAME=your-media-bucket
2GCS_PUBLIC_FILES=true
3GCS_UNIFORM=false
4GCS_SERVICE_ACCOUNT={...contents of your service account JSON...}

    Restart Strapi after these changes.

    Step 2: Create Media and Category Content Types

    Build your media item content type through the Content-Type Builder in the admin panel during development. The schema includes title, description, file upload field, thumbnail, and category relationship.

    Next, create a category content type with name and slug fields for organization. Establish a one-to-many relationship where each category contains multiple media items. Strapi's API generation automatically provides endpoints like /api/media-items?populate=*&filters[category][slug][$eq]=images for querying media by category.

    Step 3: Set Up Cloud SQL and Connect to Strapi

    Return to the Cloud SQL setup from the earlier section, then configure your production database connection with the Unix socket path. The connection string format /cloudsql/PROJECT_ID:REGION:INSTANCE_NAME enables the direct socket connection required by App Engine.

    Test your connection locally using Cloud SQL Proxy:

    1./cloud-sql-proxy PROJECT_ID:REGION:INSTANCE_NAME
2NODE_ENV=development npm run develop

    Step 4: Configure Auto-Scaling Rules

    Adjust your app.yaml scaling parameters based on expected traffic patterns:

    1automatic_scaling:
2  min_instances: 1
3  max_instances: 5
4  target_cpu_utilization: 0.65
5  target_throughput_utilization: 0.75
6  max_concurrent_requests: 80

    Set min_instances: 1 to eliminate cold starts for the admin panel. Configure max_instances: 10 as a cost control measure. The target_cpu_utilization: 0.65 threshold configures scaling to maintain average CPU usage at approximately 65% across instances.

    Step 5: Deploy and Monitor with Cloud Console

    Now deploy your complete application:

    1gcloud app deploy

    Monitor your deployment through Cloud Console → App Engine → Versions. The dashboard shows instance counts, request latency, error rates, and CPU utilization in real-time.

    Test your API endpoints with:

    1curl https://YOUR_PROJECT_ID.uc.r.appspot.com/api/media-items

    From there, check the Cloud Console Logs Explorer for detailed request traces and error debugging. Consider setting up alert policies for 4xx/5xx error rates and instance scaling events.

    Strapi Open Office Hours

    If you have any questions about Strapi 5 or just would like to stop by and say hi, you can join us at Strapi's Discord Open Office Hours, Monday through Friday, from 12:30 pm to 1:30 pm CST: Strapi Discord Open Office Hours.
    For more details, visit the Strapi documentation and Google App Engine documentation.

    tweet selection