跳到主要内容

调用 MySQL 数据库

概述​

「云函数」提供了多种方式连接和操作 MySQL 数据库，满足不同场景的应用需求。根据您的数据库部署位置和网络环境，选择合适的连接方式：

连接方式使用场景优势
云开发 MySQL（推荐）使用云开发环境自带的 MySQL 数据库配置简单，自动内网直连
内网互联连接腾讯云其他 MySQL 实例高性能，低延迟，安全
公网连接连接任意可公网访问的 MySQL 实例灵活性高，适用范围广

快速开始​

步骤 1：准备数据库​

  1. 登录 云开发平台/MySQL 数据库
  2. 根据您的情况选择：
    • 已有数据库：参考 MySQL 迁移至自有账号 文档，将数据库迁移到您的自有腾讯云账号，迁移后可支持 VPC 内网连接
    • 首次使用：系统将提示您初始化数据库，选择私有网络及子网后确认
  3. 在 数据库设置 页面复制「内网连接地址」
连接字符串格式

格式：mysql://root:密码@内网地址:3306/tcb

步骤 2：安装数据库驱动​

在云函数项目中安装 mysql2：

npm install mysql2 --save

步骤 3：配置网络连接​

  1. 进入 云开发平台/云函数
  2. 选择云函数，进入「函数配置」页面
  3. 开启「高级配置/私有网络」
  4. 选择云开发 MySQL 数据库所在的 VPC
重要

配置 VPC 后，云函数默认无法访问公网。如需同时访问公网和内网，请参考 内网互联配置

步骤 4：编写云函数代码​

const mysql = require('mysql2/promise');

// 全局连接池
let pool;

function getPool() {
  if (!pool) {
    pool = mysql.createPool({
      host: process.env.DB_HOST,
      port: process.env.DB_PORT || 3306,
      user: process.env.DB_USER || 'root',
      password: process.env.DB_PASSWORD,
      database: process.env.DB_NAME || 'tcb',
      waitForConnections: true,
      connectionLimit: 5,
      queueLimit: 0,
      acquireTimeout: 60000,
      timeout: 60000,
      charset: 'utf8mb4'
    });
  }
  return pool;
}

exports.main = async (event, context) => {
  try {
    const pool = getPool();
    const connection = await pool.getConnection();
    
    try {
      const [rows] = await connection.query('SELECT * FROM persons LIMIT 10');
      return { success: true, data: rows };
    } finally {
      connection.release();
    }
  } catch (error) {
    console.error('数据库操作失败:', error);
    return { success: false, error: error.message };
  }
};

步骤 5：配置环境变量​

在云函数的「环境变量」中配置：

环境变量说明示例值
DB_HOST数据库地址gz-xxxxx.mysql.tencentcdb.com
DB_PORT端口3306
DB_USER用户名root
DB_PASSWORD密码your_password
DB_NAME数据库名称tcb
使用连接字符串

也可以配置 CONNECTION_URI 环境变量，直接使用完整连接字符串

步骤 6：测试连接​

部署后，在云函数控制台点击「测试」按钮，如果连接成功，将返回数据库中的记录。

连接方式详解​

配置差异对比​

三种连接方式的核心差异仅在于网络配置,代码实现完全相同：

连接方式网络配置数据库地址适用场景
云开发 MySQL配置 VPC（数据库所在 VPC）内网地址云开发项目首选
内网互联开启内网互联（目标 VPC）内网地址已有腾讯云 MySQL
公网连接无需配置公网地址第三方或自建数据库
配置建议
  • 云开发 MySQL：直接使用「快速开始」即可,最简单
  • 腾讯云 MySQL：仅需调整网络配置为「内网互联」,其他步骤相同
  • 公网 MySQL：无需网络配置,但需确保数据库已开启公网访问

公网连接特殊说明​

安全配置​

安全提醒

公网连接存在安全风险，请确保：

  • 使用强密码
  • 配置防火墙规则，限制访问来源
  • 定期更新数据库版本和安全补丁
  • 生产环境建议使用内网连接

示例表结构​

如需创建测试表,可参考以下 SQL：

CREATE TABLE persons (
  id INT AUTO_INCREMENT PRIMARY KEY,
  name VARCHAR(100) NOT NULL,
  age INT NOT NULL,
  email VARCHAR(255) UNIQUE,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);

-- 插入测试数据
INSERT INTO persons (name, age, email) VALUES 
  ('张三', 25, 'zhangsan@example.com'), 
  ('李四', 30, 'lisi@example.com');

数据库操作​

基础 CRUD 操作​

在云函数中实现完整的增删改查：

const mysql = require('mysql2/promise');

let pool;

function getPool() {
  if (!pool) {
    pool = mysql.createPool({
      host: process.env.DB_HOST,
      port: process.env.DB_PORT || 3306,
      user: process.env.DB_USER || 'root',
      password: process.env.DB_PASSWORD,
      database: process.env.DB_NAME || 'tcb',
      connectionLimit: 5,
      waitForConnections: true,
      charset: 'utf8mb4'
    });
  }
  return pool;
}

exports.main = async (event, context) => {
  const { action, data } = event;
  
  try {
    const pool = getPool();
    const connection = await pool.getConnection();
    
    try {
      let result;
      
      switch (action) {
        case 'list':
          // 查询列表
          const [rows] = await connection.query(
            'SELECT * FROM persons ORDER BY created_at DESC LIMIT 10'
          );
          result = { success: true, data: rows };
          break;
          
        case 'create':
          // 创建记录
          const { name, age, email } = data;
          const [insertResult] = await connection.query(
            'INSERT INTO persons (name, age, email) VALUES (?, ?, ?)',
            [name, age, email]
          );
          result = { 
            success: true, 
            data: { id: insertResult.insertId, name, age, email }
          };
          break;
          
        case 'update':
          // 更新记录
          const { id, ...updateData } = data;
          const [updateResult] = await connection.query(
            'UPDATE persons SET ? WHERE id = ?',
            [updateData, id]
          );
          result = { 
            success: true, 
            affectedRows: updateResult.affectedRows 
          };
          break;
          
        case 'delete':
          // 删除记录
          const [deleteResult] = await connection.query(
            'DELETE FROM persons WHERE id = ?',
            [data.id]
          );
          result = { 
            success: true, 
            affectedRows: deleteResult.affectedRows 
          };
          break;
          
        default:
          result = { success: false, error: '不支持的操作' };
      }
      
      return result;
    } finally {
      connection.release();
    }
  } catch (error) {
    console.error('数据库操作失败:', error);
    return { success: false, error: error.message };
  }
};

Web 应用集成（Express/Koa）​

const express = require('express');
const mysql = require('mysql2/promise');
const router = express.Router();

// 创建连接池
const pool = mysql.createPool({
  host: process.env.DB_HOST,
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  database: process.env.DB_NAME,
  port: process.env.DB_PORT || 3306,
  connectionLimit: 10,
  charset: 'utf8mb4'
});

// 健康检查
router.get('/health', async (req, res) => {
  try {
    const connection = await pool.getConnection();
    await connection.ping();
    connection.release();
    res.json({ status: 'healthy' });
  } catch (error) {
    res.status(500).json({ status: 'unhealthy', error: error.message });
  }
});

// 分页查询
router.get('/users', async (req, res) => {
  const { page = 1, limit = 10 } = req.query;
  const offset = (page - 1) * limit;
  
  try {
    const connection = await pool.getConnection();
    try {
      const [countResult] = await connection.query('SELECT COUNT(*) as total FROM persons');
      const [rows] = await connection.query(
        'SELECT * FROM persons ORDER BY created_at DESC LIMIT ? OFFSET ?',
        [parseInt(limit), parseInt(offset)]
      );
      
      res.json({ 
        success: true, 
        data: rows,
        pagination: {
          page: parseInt(page),
          limit: parseInt(limit),
          total: countResult[0].total
        }
      });
    } finally {
      connection.release();
    }
  } catch (error) {
    console.error('查询失败:', error);
    res.status(500).json({ success: false, error: '查询失败' });
  }
});

// 创建用户
router.post('/users', async (req, res) => {
  const { name, age, email } = req.body;
  
  if (!name || !age || !email) {
    return res.status(400).json({ error: '缺少必要参数' });
  }
  
  try {
    const connection = await pool.getConnection();
    try {
      const [result] = await connection.query(
        'INSERT INTO persons (name, age, email) VALUES (?, ?, ?)',
        [name, age, email]
      );
      res.status(201).json({ 
        success: true, 
        data: { id: result.insertId, name, age, email }
      });
    } finally {
      connection.release();
    }
  } catch (error) {
    if (error.code === 'ER_DUP_ENTRY') {
      return res.status(409).json({ error: '邮箱已存在' });
    }
    res.status(500).json({ error: '创建失败' });
  }
});

// 更新用户
router.put('/users/:id', async (req, res) => {
  const { id } = req.params;
  const { name, age, email } = req.body;
  
  try {
    const connection = await pool.getConnection();
    try {
      const [result] = await connection.query(
        'UPDATE persons SET name = ?, age = ?, email = ? WHERE id = ?',
        [name, age, email, id]
      );
      
      if (result.affectedRows === 0) {
        return res.status(404).json({ error: '用户不存在' });
      }
      res.json({ success: true });
    } finally {
      connection.release();
    }
  } catch (error) {
    res.status(500).json({ error: '更新失败' });
  }
});

// 删除用户
router.delete('/users/:id', async (req, res) => {
  const { id } = req.params;
  
  try {
    const connection = await pool.getConnection();
    try {
      const [result] = await connection.query('DELETE FROM persons WHERE id = ?', [id]);
      
      if (result.affectedRows === 0) {
        return res.status(404).json({ error: '用户不存在' });
      }
      res.json({ success: true });
    } finally {
      connection.release();
    }
  } catch (error) {
    res.status(500).json({ error: '删除失败' });
  }
});

module.exports = router;

测试 API​

# 健康检查
curl https://your-domain.com/health

# 获取用户列表
curl https://your-domain.com/users

# 创建用户
curl -X POST https://your-domain.com/users \
  -H "Content-Type: application/json" \
  -d '{"name":"张三","age":25,"email":"test@example.com"}'

# 更新用户
curl -X PUT https://your-domain.com/users/1 \
  -H "Content-Type: application/json" \
  -d '{"name":"李四","age":30,"email":"lisi@example.com"}'

# 删除用户
curl -X DELETE https://your-domain.com/users/1

最佳实践​

连接池配置优化​

const pool = mysql.createPool({
  host: process.env.DB_HOST,
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  database: process.env.DB_NAME,
  port: process.env.DB_PORT ? Number(process.env.DB_PORT) : 3306,
  
  // 连接池配置
  connectionLimit: 10,        // 最大连接数
  queueLimit: 0,             // 队列限制，0 表示无限制
  acquireTimeout: 60000,     // 获取连接超时时间
  timeout: 60000,            // 查询超时时间
  
  // 重连配置
  reconnect: true,           // 自动重连
  
  // 字符集配置
  charset: 'utf8mb4',        // 支持 emoji 和特殊字符
  
  // SSL 配置（生产环境推荐）
  ssl: process.env.NODE_ENV === 'production' ? {
    rejectUnauthorized: false
  } : false,
  
  // 时区配置
  timezone: '+08:00'
});

错误处理和重试机制​

// 带重试的数据库操作
async function executeWithRetry(operation, maxRetries = 3) {
  let lastError;
  
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await operation();
    } catch (error) {
      lastError = error;
      
      // 判断是否为可重试的错误
      if (isRetryableError(error) && i < maxRetries - 1) {
        const delay = Math.pow(2, i) * 1000; // 指数退避
        await new Promise(resolve => setTimeout(resolve, delay));
        continue;
      }
      
      throw error;
    }
  }
  
  throw lastError;
}

function isRetryableError(error) {
  const retryableCodes = [
    'ECONNRESET',
    'ETIMEDOUT',
    'ENOTFOUND',
    'ER_LOCK_WAIT_TIMEOUT',
    'PROTOCOL_CONNECTION_LOST'
  ];
  
  return retryableCodes.includes(error.code);
}

// 使用示例
router.get('/users', async (req, res) => {
  try {
    const result = await executeWithRetry(async () => {
      const connection = await pool.getConnection();
      try {
        const [rows] = await connection.query('SELECT * FROM persons');
        return rows;
      } finally {
        connection.release();
      }
    });
    
    res.json({ success: true, data: result });
  } catch (error) {
    console.error('查询失败:', error);
    res.status(500).json({ success: false, error: '查询失败' });
  }
});

事务处理​

// 事务处理示例
async function transferMoney(fromUserId, toUserId, amount) {
  const connection = await pool.getConnection();
  
  try {
    await connection.beginTransaction();
    
    // 检查发送方余额
    const [fromUser] = await connection.query(
      'SELECT balance FROM users WHERE id = ? FOR UPDATE',
      [fromUserId]
    );
    
    if (fromUser[0].balance < amount) {
      throw new Error('余额不足');
    }
    
    // 扣除发送方余额
    await connection.query(
      'UPDATE users SET balance = balance - ? WHERE id = ?',
      [amount, fromUserId]
    );
    
    // 增加接收方余额
    await connection.query(
      'UPDATE users SET balance = balance + ? WHERE id = ?',
      [amount, toUserId]
    );
    
    // 记录转账日志
    await connection.query(
      'INSERT INTO transfer_logs (from_user_id, to_user_id, amount, created_at) VALUES (?, ?, ?, NOW())',
      [fromUserId, toUserId, amount]
    );
    
    await connection.commit();
    return { success: true, message: '转账成功' };
  } catch (error) {
    await connection.rollback();
    throw error;
  } finally {
    connection.release();
  }
}

性能监控​

// 查询性能监控
function withPerformanceMonitoring(queryFunction) {
  return async function(...args) {
    const startTime = Date.now();
    const queryId = Math.random().toString(36).substr(2, 9);
    
    console.log(`[${queryId}] 查询开始:`, args[0]);
    
    try {
      const result = await queryFunction.apply(this, args);
      const duration = Date.now() - startTime;
      
      console.log(`[${queryId}] 查询完成: ${duration}ms`);
      
      // 记录慢查询
      if (duration > 1000) {
        console.warn(`[${queryId}] 慢查询检测: ${duration}ms`, {
          sql: args[0],
          params: args[1]
        });
      }
      
      return result;
    } catch (error) {
      const duration = Date.now() - startTime;
      console.error(`[${queryId}] 查询失败: ${duration}ms`, {
        error: error.message,
        sql: args[0]
      });
      throw error;
    }
  };
}

// 包装连接的查询方法
const originalQuery = pool.query.bind(pool);
pool.query = withPerformanceMonitoring(originalQuery);

常见问题​

连接问题​

连接超时怎么办？

可能原因：

  1. 网络延迟过高
  2. 数据库服务器负载过高
  3. 防火墙阻止连接

解决方案：

// 增加超时时间
const pool = mysql.createPool({
  // ... 其他配置
  acquireTimeout: 120000,  // 增加到 2 分钟
  timeout: 120000,         // 查询超时 2 分钟
  connectTimeout: 60000    // 连接超时 1 分钟
});
连接数过多怎么处理？

解决方案：

  1. 优化连接池配置
  2. 及时释放连接
  3. 使用连接监控
// 监控连接池状态
setInterval(() => {
  console.log('连接池状态:', {
    总连接数: pool._allConnections.length,
    空闲连接数: pool._freeConnections.length,
    使用中连接数: pool._acquiringConnections.length
  });
}, 30000);

性能问题​

查询速度慢怎么优化？

优化策略：

  1. 添加适当的索引
  2. 优化 SQL 查询
  3. 使用连接池
  4. 实施查询缓存
-- 添加索引示例
CREATE INDEX idx_persons_email ON persons(email);
CREATE INDEX idx_persons_age ON persons(age);
CREATE INDEX idx_persons_created_at ON persons(created_at);

安全问题​

如何防止 SQL 注入？

防护措施：

  1. 始终使用参数化查询
  2. 验证输入数据
  3. 使用最小权限原则
// 正确的参数化查询
const [rows] = await connection.query(
  'SELECT * FROM persons WHERE name = ? AND age > ?',
  [userName, minAge]
);

// 错误的字符串拼接（容易受到 SQL 注入攻击）
// const query = `SELECT * FROM persons WHERE name = '${userName}'`;
性能建议
  • 在生产环境中启用连接池以提高性能
  • 对于频繁查询的字段添加索引
  • 使用事务确保数据一致性
  • 定期监控数据库性能和慢查询日志
安全提醒
  • 避免在代码中硬编码数据库密码
  • 使用参数化查询防止 SQL 注入
  • 定期更新数据库版本和安全补丁
  • 配置适当的防火墙规则