Building and Deploying a Remote MCP Server to Google Cloud Run in Under 10 Minutes

ANDY MICHAEL CALIZAYA LADERA — Fri, 28 Nov 2025 02:13:17 +0000

Unlock the Power of Model Context Protocol with Serverless Architecture

The Model Context Protocol (MCP) is revolutionizing how AI applications connect to external data sources and tools. If you're looking to build your own MCP server and deploy it efficiently, Google Cloud Run offers a perfect serverless solution. Here's how you can go from zero to deployed in under 10 minutes.

What is MCP?

MCP is an open protocol that enables AI models like Claude to connect securely to external resources such as databases, APIs, and tools. Unlike traditional plugins, MCP provides a standardized way for models to discover and use capabilities without hard-coded integrations.

Prerequisites

Before we begin, ensure you have:

A Google Cloud account
Node.js 18+ installed locally
Basic knowledge of JavaScript/TypeScript
Google Cloud CLI installed and configured

Step 1: Initialize Your MCP Server Project


bash
mkdir my-mcp-server
cd my-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk
npm install -D typescript @types/node
Create a tsconfig.json:

json
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}
Step 2: Build a Simple Weather MCP Server
Create src/server.ts:

typescript
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequest,
  ListToolsRequest,
  ToolSchema,
} from "@modelcontextprotocol/sdk/types.js";

const server = new Server(
  {
    name: "weather-mcp-server",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

// Define available tools
const tools: ToolSchema[] = [
  {
    name: "get_weather",
    description: "Get current weather for a city",
    inputSchema: {
      type: "object",
      properties: {
        city: {
          type: "string",
          description: "City name",
        },
      },
      required: ["city"],
    },
  },
];

// Handle tool listing
server.setRequestHandler(ListToolsRequest, async () => {
  return { tools };
});

// Handle tool execution
server.setRequestHandler(CallToolRequest, async (request) => {
  if (request.params.name === "get_weather") {
    const city = (request.params.arguments as any).city;

    // Simulate weather API call
    const weatherData = {
      temperature: Math.floor(Math.random() * 30) + 5,
      condition: "sunny",
      humidity: Math.floor(Math.random() * 50) + 30,
    };

    return {
      content: [
        {
          type: "text",
          text: `Weather in ${city}: ${weatherData.temperature}°C, ${weatherData.condition}, ${weatherData.humidity}% humidity`,
        },
      ],
    };
  }

  throw new Error("Tool not found");
});

// Start server
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("Weather MCP Server running on stdio");
}

main().catch(console.error);
Step 3: Create Deployment Configuration
Create Dockerfile:

dockerfile
FROM node:18-alpine

WORKDIR /app

COPY package*.json ./
RUN npm ci --only=production

COPY dist/ ./dist/

ENTRYPOINT ["node", "dist/server.js"]
Create .dockerignore:

text
node_modules
npm-debug.log
src
tsconfig.json
Step 4: Build and Deploy to Cloud Run
Build your project:

bash
npm run build
Build and push container:

bash
gcloud auth configure-docker
gcloud builds submit --tag gcr.io/your-project-id/weather-mcp-server
Deploy to Cloud Run:

bash
gcloud run deploy weather-mcp-server \
  --image gcr.io/your-project-id/weather-mcp-server \
  --platform managed \
  --region us-central1 \
  --allow-unauthenticated \
  --cpu 1 \
  --memory 512Mi
Step 5: Test Your Deployment
Once deployed, you'll get a URL for your service. Test it with:

bash
curl -X POST https://your-service-url.a.run.com \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list",
    "params": {}
  }'
Integration with MCP Clients
Claude Desktop Configuration
Add to your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json):

json
{
  "mcpServers": {
    "weather-server": {
      "command": "curl",
      "args": [
        "-X", "POST",
        "-H", "Content-Type: application/json",
        "-d", "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/list\",\"params\":{}}",
        "https://your-service-url.a.run.com"
      ]
    }
  }
}
Best Practices for Production
Authentication: Add API keys or OAuth to secure your endpoint

Monitoring: Implement Cloud Monitoring and logging

Caching: Use Memorystore for frequently accessed data

Scaling: Configure min/max instances based on your needs

Error Handling: Implement comprehensive error handling and retries

Cost Optimization
Cloud Run automatically scales to zero when not in use, making it extremely cost-effective for MCP servers. You'll only pay for:

Compute time during requests

Memory allocated

Network egress

Example Repository
Check out our complete example on GitHub:
github.com/example/mcp-weather-server

Conclusion
Deploying MCP servers to Google Cloud Run provides a scalable, cost-effective solution for extending AI capabilities. With automatic scaling, built-in security, and pay-per-use pricing, you can focus on building powerful tools rather than managing infrastructure.

The entire process—from initial setup to production deployment—can realistically be completed in under 10 minutes, making it accessible for developers of all levels to contribute to the growing MCP ecosystem.

GitHub Actions: Automating Testing in Modern DevOps Workflows

ANDY MICHAEL CALIZAYA LADERA — Sat, 05 Jul 2025 15:39:09 +0000

Introduction
In the modern software development lifecycle, continuous testing is a critical pillar. Among the many tools enabling Continuous Integration and Continuous Deployment (CI/CD), GitHub Actions has emerged as a powerful, developer-friendly solution, especially for projects hosted on GitHub. This article dives into how GitHub Actions can be used for test automation, how it compares to other tools, and provides a real-world example with a public repository.

What Is GitHub Actions?
GitHub Actions is a CI/CD platform that allows you to automate your build, test, and deployment pipelines directly in your GitHub repository. You can create workflows triggered by events such as push, pull_request, or schedule.

✳️ Key Features

Native integration with GitHub
Event-driven: Trigger workflows on git events.
Matrix builds: Run jobs in parallel with different environments.
Secrets & caching support
Free for public repositories

Why Use GitHub Actions for Test Automation?

Real-World Example: Automating Tests for a Node.js App
📂 Public Repository:
🔗 https://github.com/andyladera/github-actions-test-demo
📝 Workflow YAML: .github/workflows/node-test.yml

name: Node.js Test CI

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]

jobs:
  test:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [14, 16, 18]

    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Use Node.js ${{ matrix.node-version }}
      uses: actions/setup-node@v4
      with:
        node-version: ${{ matrix.node-version }}

    - name: Install dependencies
      run: npm install

    - name: Run tests
      run: npm test

✅ What It Does

Triggers on push or PR to main.
Runs tests on Node.js versions 14, 16, and 18.
Runs on a clean Ubuntu VM.
Outputs logs to GitHub interface.

Advanced Use Case: Parallel Testing with Matrix Builds
GitHub Actions allows matrix testing, which can test multiple OS and language versions at the same time — crucial for cross-platform applications.

matrix:
  os: [ubuntu-latest, windows-latest]
  node-version: [14, 16]

Conclusion
GitHub Actions provides an efficient and integrated way to handle automated testing within the GitHub ecosystem. With native support, a growing marketplace, and community-driven development, it's a top choice for modern DevOps pipelines — especially for open-source and startup teams looking for a zero-cost solution.