devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

node.js分布式 mysql集群 Nginx均衡负载 Cluster模块多线程与从0到 linux 部署服务器_node.js 分布式部署

作者：花生_TL007 | 2024-05-23 14:24:11

赞

踩

node.js 分布式部署

一、什么是分布式计算

 所谓分布式计算是一门计算机科学，它研究如何把一个需要非常巨大的计算能力才能解决的问题分成许多小的部分，然后把这些部分分配给许多计算机进行处理，最后把这些计算结果综合起来得到最终的结果。接下来为大家详细介绍一下什么是分布式计算和它的优缺点有哪些。

二、它的优缺点有哪些

分布式计算的优点
1、 可靠性、高容错性。一台服务器的系统崩溃不会影响到其他的服务器。 （另一台服务器挂了还可以用另一台nginx会自动检测到！！！）
2、 可扩展性。在分布式计算系统可以根据需要增加更多的机器。
3、 灵活性。他可以很容易的安装、实施和调试新的服务。
4、 计算速度快。分布式计算机系统可以有多台计算机的计算能力，使得比其它系统有更快的处理速度。
5、 开放性。由于他是开放的系统，本地和远程都可以访问到该服务。
6、 高性能。相较于集中式计算机网络集群可以提供更高的性能，及更好的性价比。
分布式计算机的缺点
1、 故障排除难度高。由于分布在多台服务器上，故障排除和诊断问题难度较高。
2、 软件支持少。更少的软件支持是分布式计算机系统的主要缺点。
3、 网络基础设施成本高。网络基础设置问题，包括传输、高负载、信息丢失问题。
4、 安全性问题。开放式系统的特性让分布式计算机系统存在着数据的安全性和共享的风险问题。

三.直接从0开始到结束最详细node实现分布式第一个步骤图了解分布式步骤

  ​​​​​​ 1.Nginx(负载均衡、调度) -> Node集群 -> Redis(同步状态)

  四.准备工作 

    1. 两台linux服务器

    2.部署两台 node express服务  

    3.初始化mysql 数据库2个

    4.并且通过当前Ip:8090可以查询到数据库信息数据

  五.在某一台服务器进行Nginx配置负载均衡

      1.nginx.config配置如下 复制则可以用

   

  1. user  www www;
  2. worker_processes auto;
  3. error_log  /www/wwwlogs/nginx_error.log  crit;
  4. pid        /www/server/nginx/logs/nginx.pid;
  5. worker_rlimit_nofile 51200;
  6.  
  7. events
  8.     {
  9.         use epoll;
  10.         worker_connections 51200;
  11.         multi_accept on;
  12.     }
  13.  
  14. http
  15.     {
  16.         include       mime.types;
  17. 		#include luawaf.conf;
  18.  
  19. 		include proxy.conf;
  20.  
  21.         default_type  application/octet-stream;
  22.  
  23.         server_names_hash_bucket_size 512;
  24.         client_header_buffer_size 32k;
  25.         large_client_header_buffers 4 32k;
  26.         client_max_body_size 50m;
  27.  
  28.         sendfile   on;
  29.         tcp_nopush on;
  30.  
  31.         keepalive_timeout 60;
  32.  
  33.         tcp_nodelay on;
  34.  
  35.         fastcgi_connect_timeout 300;
  36.         fastcgi_send_timeout 300;
  37.         fastcgi_read_timeout 300;
  38.         fastcgi_buffer_size 64k;
  39.         fastcgi_buffers 4 64k;
  40.         fastcgi_busy_buffers_size 128k;
  41.         fastcgi_temp_file_write_size 256k;
  42. 		fastcgi_intercept_errors on;
  43.  
  44.         gzip on;
  45.         gzip_min_length  1k;
  46.         gzip_buffers     4 16k;
  47.         gzip_http_version 1.1;
  48.         gzip_comp_level 2;
  49.         gzip_types     text/plain application/javascript application/x-javascript text/javascript text/css application/xml;
  50.         gzip_vary on;
  51.         gzip_proxied   expired no-cache no-store private auth;
  52.         gzip_disable   "MSIE [1-6]\.";
  53.  
  54.         limit_conn_zone $binary_remote_addr zone=perip:10m;
  55. 		limit_conn_zone $server_name zone=perserver:10m;
  56.  
  57.         server_tokens off;
  58.         access_log off;
  59. # 均衡的两台服务器域名访问当前域名:80则可以轮询分配到两台不同服务上去
  60. upstream sample {
  61. 	      server 127.0.0.1:8090;  
  62. 	      server xxxxx :8090;
  63. 	      keepalive 64;
  64. 	    }
  65. server
  66.     {
  67.         listen 80;
  68.         server_name localhost;
  69.  
  70.         #error_page   404   /404.html;
  71.         include enable-php.conf;
  72.  
  73.         location ~ .*\.(gif|jpg|jpeg|png|bmp|swf)$
  74.         {
  75.            root /www/server/nginx/html/seat;
  76.         }
  77.  
  78.         location / {
  79.         proxy_redirect off;
  80.                proxy_set_header X-Real-IP $remote_addr;
  81.                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
  82.                proxy_set_header X-Forwarded-Proto $scheme;
  83.                proxy_set_header Host $http_host;
  84.                proxy_set_header X-NginX-Proxy true;
  85.                proxy_set_header Connection "";
  86.                proxy_http_version 1.1;
  87.                proxy_pass http://sample;
  88.   # 均衡配置网络
  89.         }
  90.  
  91.         location /api/ {								
  92. 	    proxy_pass http://120.25.74.229:8000/; 			
  93.         }
  94.           # 开启高效文件传输模式 只能80端口能访问到文件
  95.           # http://43.138.192.215:80/app/down/文件名.xls
  96.          # 如果nginx listen 80    那么将无法下载因为80被占用 只能把html文件代理到8090 9000才能正常80下载
  97.         location ^~ /download/ {
  98.         alias /app/down/;
  99.  
  100.         if ($request_filename ~* ^.*?\.(html|doc|pdf|zip|docx|txt|exe|rar)$) {
  101.             add_header Content-Disposition attachment;
  102.             add_header Content-Type application/octet-stream;
  103.         }
  104.             sendfile on;   # 开启高效文件传输模式
  105.             autoindex on;  # 开启目录文件列表
  106.             autoindex_exact_size on;  # 显示出文件的确切大小，单位是bytes
  107.             autoindex_localtime on;  # 显示的文件时间为文件的服务器时间
  108.             charset utf-8,gbk;  # 避免中文乱码
  109.       }
  110.  
  111.         location ~ .*\.(js|css)?$
  112.         {
  113.             root /www/server/nginx/html/seat;
  114.             expires      12h;
  115.         }
  116.  
  117.         location ~ /\.
  118.         {
  119.             deny all;
  120.         }
  121.  
  122.         access_log  /www/wwwlogs/access.log;
  123.     }
  124. include /www/server/panel/vhost/nginx/*.conf;
  125. }
  126.

3.记得nginx -s reload 重启

4.现在我们访问 xxxx:80/get/userInfo 多访问几次则可以分配调用

    

 5. 现在已经实现接口统一域名利用nginx实习了分配服务器了

  六.现在我们要实现node.js多线程执行监听8090端口实现均衡负载监听

  理解一下：

Cluster模块的一个显著优点是可以共享同一个socket连接，这代表可以使用Cluster模块实现简单的负载均衡。

如果一个子进程崩掉不会影响其他进程！！！

Cluster模块采用的是经典的主从模型，由master进程来管理所有的子进程，可以使用cluster.isMaster属性判断当前进程是master还是worker，其中主进程不负责具体的任务处理，其主要工作是负责调度和管理，上面的代码中，所有的子进程都监听8090端口。

通常情况下，如果多个 Node 进程监听同一个端口时会出现Error: listen EADDRINUS的错误，而Cluster模块能够让多个子进程监听同一个端口的原因是master进程内部启动了一个 TCP 服务器，而真正监听端口的只有这个服务器，当来自前端的请求触发服务器的connection事件后，master会将对应的socket句柄发送给子进程

  1. const exportsmodule=require('./init')  // 导入逻辑js
  2. const cluster = require('cluster')  // 开启多线程模块
  3. const cpuCoreLength = require('os').cpus().length // 获取cup核心
  4. const express = require('express')
  5. const app = express()
  6. const knex = require('knex')
  7.   
  8. // 判断是否为主线程是则开启子线程
  9. if (cluster.isMaster) {
  10.   for (let i = 0; i < cpuCoreLength; i++) {
  11.       cluster.fork() // 开启子进程
  12.   }
  13.  // 判断是否出错出错退出
  14.   cluster.on('exit', worker => {
  15.       console.log('子进程退出');
  16.       cluster.fork() // 进程守护
  17.   })
  18. } else {
  19.   // 相当于直接把代码放在这里执行
  20.   // Cluster模块负载均衡监听开启TIP的一个显著优点是可以共享同一个socket连接，这代表可以使用 
  21.  // Cluster模块实现简单的负载均衡
  22.   exportsmodule.InitFn(app,knex)
  23. }
  24.  
  25. //init.js代码如下
  26.  
  27.  
  28. module.exports.InitFn = (app,knex) => {
  29.   app.get('/get/userInfo', function (req, res) {
  30.     knex('employee')
  31.       .select()
  32.       .limit(1000)
  33.       .then(results => {
  34.         console.log('userInfo查询success')
  35.         res.send({
  36.           msg: 'data',
  37.           data: results
  38.         })
  39.       })
  40.       .catch(reason => {
  41.         console.log('报错了', reason)
  42.       })
  43.   })
  44. // 按理会打印自己cup的核心的 几次
  45.   app.listen(8090, () => console.log('服务启动成功'))
  46. }

七.使用mysql集群均衡分配查询数据库

 1.node连接事务均衡分配

 2. 把两台服务器都采用一样的集权分配查询

3.mysql npm包是有集合的 如果用knex是没有集合mysql的所以得自己写

  1. // 使用原生mysql
  2. const mysql = require('mysql')
  3. const poolCluster = mysql.createPoolCluster({
  4.   removeNodeErrorCount: 1, // 失败立即删除
  5.   defaultSelector: 'RR' //轮转分配跟轮询差不多按需分配
  6. })
  7. const mysqlNodes = {
  8.   node1: {
  9.     host: '127.0.0.1',
  10.     port: 3306,
  11.     user: 'xxx',
  12.     password: 'root',
  13.     database: 'databaseone',
  14.     charset: 'utf8',
  15.     waitForConnections: true,
  16.     connectionLimit: 10, //最多连接
  17.     queueLimit: 0
  18.   },
  19.   node2: {
  20.     host: 'xxxx',
  21.     port: 3306,
  22.     user: 'xxx',
  23.     password: 'root',
  24.     database: 'databaseone',
  25.     charset: 'utf8',
  26.     waitForConnections: true,
  27.     connectionLimit: 10,
  28.     queueLimit: 0
  29.   }
  30. }
  31. // 循环添加集群让poolCluster均衡配分数据库
  32. for (let node in mysqlNodes) {
  33.   poolCluster.add(`${node}`, mysqlNodes[`${node}`])
  34. }
  35. // 定义连接数据库
  36. class MysqlModel {
  37.   /**
  38.    * 实例化mysql
  39.    */
  40.   getConnection () {
  41.     return new Promise((resolve, reject) => {
  42.       poolCluster.getConnection(function (err, connection) {
  43.         if (err) {
  44.           reject(err)
  45.         } else {
  46.           console.log(60, 'mysql连接成功')
  47.           resolve([connection, poolCluster])
  48.         }
  49.       })
  50.     })
  51.   }
  52. }
  53. // 每次查询都能均衡分配集群node
  54. module.exports.InitFn = (app, knex) => {
  55.   app.get('/get/userInfo', async function (req, res) {
  56.     const db = new MysqlModel()
  57.     const [conn, pool] = await db.getConnection()
  58.     const sql = 'select * from employee limit 0,100'
  59.     conn.query(sql, function (error, results, fields) {
  60.       res.send({
  61.         msg: 'data',
  62.         data: results
  63.       })
  64.     })
  65.   })
  66.   //   app.get('/get/userInfo', function (req, res) {
  67.   //     knex('employee')
  68.   //       .select()
  69.   //       .limit(1000)
  70.   //       .then(results => {
  71.   //         console.log('userInfo查询success')
  72.   //         res.send({
  73.   //           msg: 'data',
  74.   //           data: results
  75.   //         })
  76.   //       })
  77.   //       .catch(reason => {
  78.   //         console.log('报错了', reason)
  79.   //       })
  80.   //   })
  81.   app.listen(8090, () => console.log('服务启动成功'))
  82. }

    现在我们访问起初Nginx负载ip 

    就可以实现均衡服务器以及均衡数据库

  

总结：

  Nginx均衡分配----->node多线程均衡分配逻辑----->服务器实现mysql集群均衡分配查询，删除，增操作。 实现简单从0到mysql 分布式服务器数据库。

后面需要解决的问题：

 1.mysql数据同步  另一个文章

 mysql主从同步 node.js分布式解决数据库同步问题的各种坑点分析._大福ya的博客-CSDN博客

  2.redis缓存 整理中---

  等待后续文章可以点点关注或者赞谢谢啦！！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/613173
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号