阿里云函数计算FC实现网站定时任务与自动化的完全指南

import json
import logging
import os
import requests
logger = logging.getLogger()
def handler(event, context):
    # 解析定时触发器传入的事件
    evt = json.loads(event) if isinstance(event, str) else event
    trigger_name = evt.get(\"triggerName\", \"\")
    trigger_time = evt.get(\"triggerTime\", \"\")
    payload = evt.get(\"payload\", \"\")
    
    logger.info(f\"触发器名称: {trigger_name}, 触发时间: {trigger_time}\")
    
    # 在这里编写你的业务逻辑
    # 例如：调用API、发送邮件、处理数据等
    try:
        # 示例：调用外部API
        api_url = os.environ.get(\"API_URL\", \"https://api.example.com/data\")
        response = requests.get(api_url, timeout=30)
        logger.info(f\"API调用成功，状态码: {response.status_code}\")
        
        return {
            \"status\": \"success\",
            \"message\": \"定时任务执行完成\",
            \"triggerTime\": trigger_time,
            \"payload\": payload
        }
    except Exception as e:
        logger.error(f\"任务执行失败: {str(e)}\")
        return {
            \"status\": \"error\",
            \"message\": str(e)
        }

const axios = require('axios');
exports.handler = async (event, context) => {
    // 解析定时触发器传入的事件
    const evt = typeof event === 'string' ? JSON.parse(event) : event;
    const triggerName = evt.triggerName || '';
    const triggerTime = evt.triggerTime || '';
    const payload = evt.payload || '';
    
    console.log(`触发器名称: ${triggerName}, 触发时间: ${triggerTime}`);
    
    try {
        // 在这里编写你的业务逻辑
        // 例如：调用API、发送邮件、处理数据等
        const apiUrl = process.env.API_URL || 'https://api.example.com/data';
        const response = await axios.get(apiUrl, { timeout: 30000 });
        console.log(`API调用成功，状态码: ${response.status}`);
        
        return {
            status: 'success',
            message: '定时任务执行完成',
            triggerTime: triggerTime,
            payload: payload
        };
    } catch (error) {
        console.error(`任务执行失败: ${error.message}`);
        return {
            status: 'error',
            message: error.message
        };
    }
};

package com.example.fc;
import com.aliyun.fc.runtime.Context;
import com.aliyun.fc.runtime.StreamRequestHandler;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
public class TimerTaskHandler implements StreamRequestHandler {
    @Override
    public void handleRequest(InputStream inputStream, OutputStream outputStream, Context context) throws IOException {
        // 读取事件内容
        String event = new String(inputStream.readAllBytes(), StandardCharsets.UTF_8);
        context.getLogger().info("收到定时触发事件: " + event);
        
        try {
            // 在这里编写你的业务逻辑
            // 例如：调用API、处理数据等
            String apiUrl = System.getenv().getOrDefault("API_URL", "https://api.example.com/data");
            URL url = new URL(apiUrl);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            connection.setConnectTimeout(30000);
            connection.setReadTimeout(30000);
            
            int responseCode = connection.getResponseCode();
            context.getLogger().info("API调用成功，状态码: " + responseCode);
            connection.disconnect();
            
            String response = "{\"status\":\"success\",\"message\":\"定时任务执行完成\"}";
            outputStream.write(response.getBytes(StandardCharsets.UTF_8));
        } catch (Exception e) {
            context.getLogger().severe("任务执行失败: " + e.getMessage());
            String errorResponse = "{\"status\":\"error\",\"message\":\"" + e.getMessage() + "\"}";
            outputStream.write(errorResponse.getBytes(StandardCharsets.UTF_8));
        }
    }
}

package main
import (
    \"context\"
    \"encoding/json\"
    \"fmt\"
    \"io\"
    \"net/http\"
    \"os\"
    \"time\"
)
type TimerEvent struct {
    TriggerTime string `json:\"triggerTime\"`
    TriggerName string `json:\"triggerName\"`
    Payload     string `json:\"payload\"`
}
type Response struct {
    Status      string `json:\"status\"`
    Message     string `json:\"message\"`
    TriggerTime string `json:\"triggerTime,omitempty\"`
}
func handler(ctx context.Context, event []byte) ([]byte, error) {
    var timerEvent TimerEvent
    if err := json.Unmarshal(event, &timerEvent); err != nil {
        return nil, fmt.Errorf(\"解析事件失败: %v\", err)
    }
    
    fmt.Printf(\"触发器名称: %s, 触发时间: %s\\n\", timerEvent.TriggerName, timerEvent.TriggerTime)
    
    // 在这里编写你的业务逻辑
    apiURL := os.Getenv(\"API_URL\")
    if apiURL == \"\" {
        apiURL = \"https://api.example.com/data\"
    }
    
    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Get(apiURL)
    if err != nil {
        return nil, fmt.Errorf(\"API调用失败: %v\", err)
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Printf(\"API调用成功，状态码: %d\\n\", resp.StatusCode)
    
    response := Response{
        Status:      \"success\",
        Message:     \"定时任务执行完成\",
        TriggerTime: timerEvent.TriggerTime,
    }
    return json.Marshal(response)
}
func main() {
    // 启动HTTP服务器监听函数计算平台的调用
    http.HandleFunc(\"/\", func(w http.ResponseWriter, r *http.Request) {
        body, err := io.ReadAll(r.Body)
        if err != nil {
            http.Error(w, err.Error(), http.StatusBadRequest)
            return
        }
        result, err := handler(r.Context(), body)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        w.Header().Set(\"Content-Type\", \"application/json\")
        w.Write(result)
    })
    http.ListenAndServe(\":8080\", nil)
}