Centos上部署Node服务和MongoDB

文章目录

• 1.Centos上安装运行Node服务
• • [1. 安装Node.js](#1. 安装Node.js)
  • 2.验证Node.js安装
  • 3.运行Node.js应用程序
  • 4.调试Node.js应用
• 2.Centos上安装MongoDB
• 3.创建Node服务
• • 1.配置初始化文件
  • 2.创建index.js文件
  • 3.启动服务
  • 3.配置公网访问
  • • forever的引入
    • pm2的引入
  • 4.应对CORS跨域
  • • 使用cors中间件
    • 手动设置CORS响应头
  • 5.爬取数据
  • 6.编写get方法
  • 7.编写post方法
• 4.Node通过mongoose操作mongodb

1.Centos上安装运行Node服务

1. 安装Node.js

可以使用NodeSource仓库来安装Node.js，这样可以保持最新版本。以下是安装Node.js的步骤：

curl -sL https://rpm.nodesource.com/setup_16.x | sudo bash -
sudo yum install -y nodejs

这将安装Node.js版本16.x的稳定版

2.验证Node.js安装

安装完成后，可以通过以下命令验证Node.js是否正确安装：

node -v

这将显示安装的Node.js版本。

3.运行Node.js应用程序

假设你有一个名为app.js的Node.js应用程序文件，你可以通过以下命令运行它：

node app.js

确保你的应用程序文件（例如app.js）是可执行的，并且位于当前工作目录或指定路径。

4.调试Node.js应用

方式一：直接在项目启动运行时，添加上 --inspect 代码，启动后，在Chrome浏览器点开F12，会发现多了一个绿色的按钮。

node --inspect index.js

方式二：如果不打算在启动项目时就启动调试工具的话，还可以在 app.js 或者其它 js 文件里面把工具引入进来，并启动它。

const inspector = require('inspector');
inspector.open();
console.log('在app.js里面启动')

2.Centos上安装MongoDB

在CentOS上安装MongoDB，可以遵循以下步骤：

1. 配置MongoDB仓库，创建MongoDB仓库文件。
2. 安装MongoDB包。
3. 启动MongoDB服务。
4. 配置MongoDB自启动。

以下是具体的命令：

# 1. 导入MongoDB公钥
sudo rpm --import https://www.mongodb.org/static/pgp/server-4.2.asc
 
# 2. 创建MongoDB仓库文件
echo '[mongodb-org-4.2]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/4.2/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-4.2.asc' | sudo tee /etc/yum.repos.d/mongodb-org-4.2.repo
 
# 3. 安装MongoDB
sudo yum install -y mongodb-org
 
# 4. 启动MongoDB
sudo systemctl start mongod
 
# 5. 设置MongoDB开机自启
sudo systemctl enable mongod
 
# 6. 检查MongoDB服务状态
sudo systemctl status mongod

# 7. 查看运行端口
netstat -tulnp | grep mongod

3.创建Node服务

1.配置初始化文件

1. 新建文件夹

2. 输入命令npm init，生成package.json文件

3. 安装 express 、mongoose 、cors、nodemon

   • Express 是一个保持最小规模的灵活的 Node.js Web 应用程序开发框架
   • mongoose 是一个可以运行在Node.js上简化编写MongoDB验证逻辑
   • nodemon用来监视node.js应用程序中的任何更改并自动重启服务,非常适合用在开发环境中
   • cors设置CORS（跨来源资源共享）响应头

   npm i express mongoose nodemon cors

2.创建index.js文件

//导入express
const express = require('express')
//创建web服务器
const app=express()
// 通过ap.listen进行服务器的配置，并启动服务器，接收两个配置参数，一个是对应的端口号，一个是启动成功的回调函数
app.listen(9588,()=>{
    console.log('服务器启动成功');
})

3.启动服务

将文件夹整个导入到linux服务器上，注意开启的端口需要放开，linux默认只开启22端口，所以要向外部访问就得开启防火墙上对应端口访问设置

1.启动服务

node index.js

2.使用ss查看端口：

ss -tuln

3.查看防火墙对应端口是否开放

// 查看防火墙状态
systemctl status firewalld
// 查看端口状态输入以下命令：
firewall-cmd --zone=public --query-port=8080/tcp
// 发现端口没有开放，输入以下命令：
firewall-cmd --zone=public --add-port=8080/tcp --permanent
// 端口开放成功了，输入以下命令使其生效：
firewall-cmd --reload

4.注意端口是否做了映射

3.配置公网访问

forever的引入

forever一个简单的命令行工具，用于保证给定脚本（无论是否是用 Node.js 编写的）连续无间断运行。

1.下载安装

npm install forever -g

2.使用forever启动js

forever start index.js

3.停止js文件命令

forever stop index.js

4.查看启动情况

forever list

pm2的引入

如果你需要以守护进程的方式运行Node.js应用程序，可以使用如pm2这样的进程管理器。首先通过npm安装pm2：

npm install pm2 -g

然后使用pm2启动你的应用程序：

pm2 start app.js

4.应对CORS跨域

CORS需要浏览器和服务器同时支持。浏览器会自动检查某个AJAX请求是否跨源，如果是，则浏览器会首先使用OPTIONS方法发起一个预检请求（preflight request）到服务器，以获知服务器是否允许该跨源请求。服务器收到预检请求后，会在响应头中包含一些CORS相关的头部信息来告知浏览器是否允许该跨源请求。

使用cors中间件

npm install cors

然后，在你的Express应用中引入并使用它：

const express = require('express');  
const cors = require('cors');  
const app = express();  
  
// 允许来自任何源（*）的跨域请求  
// 注意：在生产环境中，你应该只允许来自特定源的请求  
app.use(cors());  
  
// 或者，你可以配置更具体的CORS选项  
app.use(cors({  
  origin: 'http://example.com', // 只允许来自http://example.com的请求  
  methods: ['GET', 'POST'], // 允许的HTTP方法  
  allowedHeaders: ['Content-Type', 'Authorization'], // 允许的HTTP头  
  credentials: true, // 是否允许携带凭证（cookies, HTTP认证等）  
}));  
  
// ... 你的其他中间件和路由  
  
app.listen(3000, () => {  
  console.log('Server is running on port 3000');  
});

手动设置CORS响应头

如果你不想使用cors中间件，你也可以在每个路由处理程序中手动设置CORS响应头：

app.get('/api/some-endpoint', (req, res) => {  
  res.setHeader('Access-Control-Allow-Origin', 'http://example.com');  
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST');  
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');  
  // 如果你的API需要凭证，确保设置这个头部  
  // res.setHeader('Access-Control-Allow-Credentials', 'true');  
  
  // ... 你的其他响应代码  
});

但请注意，手动设置CORS响应头可能会更加繁琐，并且难以维护，特别是当你的API有很多端点时。因此，使用cors中间件通常是更好的选择。

5.爬取数据

1.可以使用axios来发送HTTP请求，以及cheerio来解析返回的HTML内容

npm install axios cheerio

编写爬虫方法

//get接口的开发
app.get('/api/list', async (err, res) => {
    const {data: data1} = await getStarHistory('xiaoosnggao/vue-music', GITHUB_TOKEN);
    const {data: data2} = await getForkHistory('xiaoosnggao/vue-music', GITHUB_TOKEN);
    const {data: data3} = await getCommitHistory('xiaoosnggao/vue-music', GITHUB_TOKEN);
    const {data: data4} = await getWatchHistory('xiaoosnggao/vue-music', GITHUB_TOKEN);
    res.send({
        code: 200,
        data: [data1, data2, data3, data4]
    })
})

注意：Nodejs中不能只用使用ES6的import方法，需要修改配置或者使用require

6.编写get方法

前端代码get方法通过url传参

await axios.get(`${process.env.VUE_APP_NODE_SERVER}/api/list?id=${this.id}`);

node服务中通过req.query获取参数

//get接口的开发 查询githistory
app.get('/api/list', async (req, res) => {
    const id = req.query.id;
    console.log(id)

    if (id) {
        // 查询所有用户
        GitHistory.findOne({id: id})
            .then(users => {
                console.error('查询成功', users)
                res.send({
                    code: 200,
                    data: users
                })
            })
            .catch(err => console.error('查询失败', err));
    }
})

7.编写post方法

注意：post方法获取参数时，需要先解析JSON请求体

在Express 4.16+ 中，可以使用 express.json()

post方法前端传参通过json格式传送

await axios.post(`${process.env.VUE_APP_NODE_SERVER}/api/setList`, {
          id: this.id,
          url: 'https://github.com/immich-app/immich'
        });

node服务通过req.body获取

//post接口的开发 根据传入的id和url爬取githistory
app.post('/api/setList', async (req, res) => {
    console.log(req.body)
    const id = req.body.id;
    const url = req.body.url;
    if (id && url) {

        // 保存数据到数据库
        GitHistory.updateOne({id: id}, {
            $set: {
                id: id,
                url,
            }
        }, {upsert: true}).then(GitHistory => {
            console.log('保存成功', GitHistory);
            res.send({
                code: 200,
                data: {}
            })
        })
            .catch(err => console.error('保存失败', err));
    }

})

4.Node通过mongoose操作mongodb

1.连接服务

// 导入mongoose
const mongoose = require('mongoose');

// 连接到MongoDB数据库
mongoose.connect('mongodb://localhost:27017/mydatabase', { useNewUrlParser: true, useUnifiedTopology: true })
    .then(() => console.log('MongoDB连接成功'))
    .catch(err => console.error('MongoDB连接失败', err)); // 如果mydatabase数据库不存在会自动创建

2.定义模型

// 定义一个Schema
const GitHistorySchema = new mongoose.Schema({
    id: String,
    url: String,
    history: Object
});

// 创建模型
const GitHistory = mongoose.model('GitHistory', GitHistorySchema);

3.插入到数据库

    // 创建一个新GitHistory
    const newGitHistory = new GitHistory({ id: 83462, url:'xiaoosnggao/vue-music', history:{
            StarHistory:data1,
            ForkHistory:data2,
            CommitHistory:data3,
            WatchHistory:data4,
        } });

// 保存数据到数据库
    newGitHistory.save()
        .then(GitHistory => console.log('保存成功', GitHistory))
        .catch(err => console.error('保存失败', err));

4.使用updateOne更新数据库，并使用upsert: true可以当没有查到时，执行插入操作

        // 保存数据到数据库
        GitHistory.updateOne({id: id}, {
            $set: {
                id: id,
                url,
                history: {
                    StarHistory,
                    ForkHistory,
                    CommitHistory,
                    WatchHistory,
                }
            }
        }, {upsert: true}).then(GitHistory => {
            console.log('保存成功', GitHistory);
            res.send({
                code: 200,
                data: {
                    StarHistory,
                    ForkHistory,
                    CommitHistory,
                    WatchHistory,
                }
            })
        })
            .catch(err => console.error('保存失败', err));

5.使用findOne和条件参数，查询指定一条数据

        // 查询所有用户
        GitHistory.findOne({id: id})
            .then(users => {
                console.error('查询成功', users)
                res.send({
                    code: 200,
                    data: users
                })
            })
            .catch(err => console.error('查询失败', err));