Integrate Google App Engine with Strapi

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:

# macOS (using Homebrew)
brew install --cask google-cloud-sdk
gcloud init

# Linux (Debian/Ubuntu)
sudo apt-get install google-cloud-sdk
gcloud init

Authenticate and configure your project:

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

Enable required APIs:

gcloud services enable appengine.googleapis.com
gcloud services enable cloudbuild.googleapis.com
gcloud services enable sqladmin.googleapis.com
gcloud services enable storage.googleapis.com
gcloud 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:

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

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

{
  "scripts": {
    "develop": "strapi develop",
    "start": "strapi start",
    "build": "strapi build",
    "gcp-build": "strapi build"
  }
}

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

Add a .gcloudignore file in your project root:

.git
node_modules/
.env
.cache/
build/
.tmp/

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

module.exports = {
  host: '0.0.0.0',
  port: process.env.PORT || 8080,
  admin: {
    path: '/admin',
  },
};

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:

runtime: nodejs18
instance_class: F2

env_variables:
  NODE_ENV: production
  HOST: 0.0.0.0
  PORT: 8080
  DATABASE_HOST: /cloudsql/PROJECT_ID:REGION:INSTANCE_NAME
  DATABASE_NAME: strapi_db
  DATABASE_USERNAME: strapi_user
  GCS_BUCKET_NAME: your-bucket-name

automatic_scaling:
  min_instances: 1
  max_instances: 5
  target_cpu_utilization: 0.6
  max_concurrent_requests: 50

beta_settings:
  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:

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

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

Create your database and user:

gcloud sql databases create strapi_db --instance=strapi-db

gcloud sql users create strapi_user \
  --instance=strapi-db \
  --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:

module.exports = ({ env }) => ({
  connection: {
    client: 'postgres',
    connection: {
      host: `/cloudsql/${env('INSTANCE_CONNECTION_NAME')}`,
      port: 5432,
      database: env('DATABASE_NAME'),
      user: env('DATABASE_USERNAME'),
      password: env('DATABASE_PASSWORD'),
      ssl: false,
    },
    pool: {
      min: 2,
      max: 10,
      acquireTimeoutMillis: 30000,
      idleTimeoutMillis: 30000,
    },
  },
});

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:

# Generate secure random secret
node -p "require('crypto').randomBytes(16).toString('base64')"

# Store database password
echo -n "your-actual-password" | gcloud secrets create strapi-db-password --data-file=-

# Store JWT secret
openssl rand -base64 32 | gcloud secrets create strapi-jwt-secret --data-file=-

Grant your App Engine service account access:

PROJECT_ID=$(gcloud config get-value project)
SERVICE_ACCOUNT="${PROJECT_ID}@appspot.gserviceaccount.com"

gcloud secrets add-iam-policy-binding strapi-db-password \
  --member="serviceAccount:${SERVICE_ACCOUNT}" \
  --role="roles/secretmanager.secretAccessor"

Add the Secret Manager client library:

npm 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):

const { SecretManagerServiceClient } = require('@google-cloud/secret-manager');
const client = new SecretManagerServiceClient();

const secretCache = new Map();

async function accessSecret(secretName) {
  if (secretCache.has(secretName)) {
    return secretCache.get(secretName);
  }

  const projectId = process.env.GOOGLE_CLOUD_PROJECT;
  const name = `projects/${projectId}/secrets/${secretName}/versions/latest`;

  try {
    const [version] = await client.accessSecretVersion({ name });
    const secretValue = version.payload.data.toString('utf8');
    
    secretCache.set(secretName, secretValue);
    return secretValue;
  } catch (error) {
    console.error(`Error accessing secret ${secretName}:`, error);
    throw error;
  }
}

module.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:

const { accessSecret } = require('./utils/secrets');

async function loadSecrets() {
  process.env.DATABASE_PASSWORD = await accessSecret('strapi-db-password');
  process.env.JWT_SECRET = await accessSecret('strapi-jwt-secret');
  process.env.API_KEY = await accessSecret('strapi-api-key');
}

loadSecrets().then(() => {
  require('./src/index');
}).catch(err => {
  console.error('Failed to load secrets:', err);
  process.exit(1);
});

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:

gcloud 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:

gcloud app browse

Monitor real-time logs:

gcloud 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:

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

Next, create config/plugins.js:

module.exports = ({ env }) => ({
  upload: {
    config: {
      provider: '@strapi-community/strapi-provider-upload-google-cloud-storage',
      providerOptions: {
        bucketName: env('GCS_BUCKET_NAME'),
        publicFiles: env.bool('GCS_PUBLIC_FILES', true),
        uniform: env.bool('GCS_UNIFORM', false),
        basePath: '',
        serviceAccount: env.json('GCS_SERVICE_ACCOUNT'),
      },
    },
  },
});

Set up your Cloud Storage bucket with:

gcloud 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:

GCS_BUCKET_NAME=your-media-bucket
GCS_PUBLIC_FILES=true
GCS_UNIFORM=false
GCS_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:

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

Step 4: Configure Auto-Scaling Rules

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

automatic_scaling:
  min_instances: 1
  max_instances: 5
  target_cpu_utilization: 0.65
  target_throughput_utilization: 0.75
  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:

gcloud 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:

curl 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.