GAE跨服务任务提交策略：从Python服务调度Node.js任务

# dispatch.yaml
dispatch:
  # 将所有以 /mobile/ 开头的请求路由到 mobile-frontend 服务
  - url: "*/mobile/*"
    service: mobile-frontend

  # 将所有以 /work/ 开头的请求路由到 static-backend 服务
  - url: "*/work/*"
    service: static-backend

from google.cloud import tasks_v2
from google.protobuf import timestamp_pb2
import datetime
import json

# 配置您的项目、队列和位置信息
project = "your-gcp-project-id"
queue_name = "default" # 或您自定义的队列
location = "your-gcp-region" # 例如 "us-central1"

client = tasks_v2.CloudTasksClient()

# 构建队列的完整路径
parent = client.queue_path(project, location, queue_name)

# 任务负载数据
payload_data = {"message": "Hello from Python, processed by Node.js!"}
payload_bytes = json.dumps(payload_data).encode('utf-8')

# 定义任务
task = {
    'app_engine_http_request': {
        'http_method': tasks_v2.HttpMethod.POST,
        # 关键：设置 relative_uri 以匹配 Node.js 服务的 dispatch 规则
        'relative_uri': '/nodejs-tasks/process-data',
        'body': payload_bytes,
        'headers': {'Content-Type': 'application/json'}
    }
}

# 可选：设置任务执行时间
# schedule_time = datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(minutes=5)
# timestamp = timestamp_pb2.Timestamp()
# timestamp.FromDatetime(schedule_time)
# task['schedule_time'] = timestamp

try:
    response = client.create_task(request={"parent": parent, "task": task})
    print(f"Task created: {response.name}")
except Exception as e:
    print(f"Error creating task: {e}")

// 假设 Node.js 服务配置了处理 /nodejs-tasks/process-data 路径的路由
const express = require('express');
const app = express();
const bodyParser = require('body-parser');

app.use(bodyParser.json());

// 任务处理器路由
app.post('/nodejs-tasks/process-data', (req, res) => {
  console.log('Received task from App Engine queue.');
  console.log('Task Payload:', req.body);

  // 在这里执行 Node.js 服务的具体业务逻辑
  // 例如：处理数据、调用外部API、更新数据库等

  // 成功处理任务后，返回 2xx 状态码
  res.status(200).send('Task processed successfully by Node.js service.');
});

// 其他路由和服务器启动
const PORT = process.env.PORT || 8080;
app.listen(PORT, () => {
  console.log(`Node.js service listening on port ${PORT}`);
});

import requests
import json

# Node.js 服务的 URL 和接收任务提交指令的端点
# 在 GAE 环境中，这可能是 service-name-dot-your-project-id.region.r.appspot.com
# 或者通过 dispatch.yaml 配置的自定义域名
nodejs_service_url = "https://nodejs-service-dot-your-gcp-project-id.your-region.r.appspot.com/submit-internal-task"

# 任务负载数据，将通过 HTTP 请求发送给 Node.js 服务
task_data_for_nodejs = {
    "operation_type": "process_image",
    "image_url": "gs://my-bucket/image.jpg",
    "user_id": "12345"
}

headers = {
    "Content-Type": "application/json"
}

try:
    response = requests.post(nodejs_service_url, data=json.dumps(task_data_for_nodejs), headers=headers)
    response.raise_for_status() # 如果请求失败则抛出异常
    print(f"Successfully sent task submission request to Node.js service. Response: {response.text}")
except requests.exceptions.RequestException as e:
    print(f"Error sending request to Node.js service: {e}")

// Node.js 服务 (Express)
const express = require('express');
const { CloudTasksClient } = require('@google-cloud/tasks');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json());

const client = new CloudTasksClient();

// 配置您的项目、队列和位置信息
const project = 'your-gcp-project-id';
const queue = 'default'; // 或您自定义的队列
const location = 'your-gcp-region'; // 例如 "us-central1"

const parent = client.queuePath(project, location, queue);

// 接收来自 Python 服务的 HTTP 请求，并由 Node.js 自身提交任务
app.post('/submit-internal-task', async (req, res) => {
  console.log('Received internal task submission request from Python service.');
  const taskPayload = req.body; // 这是 Python 服务发送过来的数据

  try {
    // 构造将由 Node.js 自身处理的任务
    const task = {
      appEngineHttpRequest: {
        httpMethod: 'POST',
        // 关键：relative_uri 指向 Node.js 服务自身的处理端点
        relativeUri: '/process-task-internally',
        body: Buffer.from(JSON.stringify(taskPayload)).toString('base64'), // Base64 编码
        headers: {
          'Content-Type': 'application/json',
        },
      },
    };

    const request = { parent: parent, task: task };
    const [response] = await client.createTask(request);
    console.log(`Internal task created: ${response.name}`);
    res.status(200).send({ message: 'Internal task submitted successfully.', taskId: response.name });

  } catch (error) {
    console.error('Error submitting internal task:', error);
    res.status(500).send({ error: 'Failed to submit internal task.' });
  }
});

// Node.js 服务自身处理任务的端点
app.post('/process-task-internally', (req, res) => {
  console.log('Node.js service received and is processing its own task.');
  // req.body 包含了原始任务负载数据
  console.log('Task Data:', req.body);

  // 在这里执行 Node.js 服务的核心业务逻辑
  // ...

  res.status(200).send('Internal task processed by Node.js service.');
});

const PORT = process.env.PORT || 8080;
app.listen(PORT, () => {
  console.log(`Node.js service listening on port ${PORT}`);
});