cd ~
mkdir demorepos
cd demorepos
# ssh 和 https 或者 下载zip包都可以 下载到 ~/demorepos 目录里
git clone git@github.com:rupa/z.git

# 下载完成后  demorepos 出现了个 z 目录， z目录里 有个 z.sh
cd z

# 获取 z.sh 的目录
pwd
c/Users/hjx/demorepos/z
# 补全这个目录 
c/Users/hjx/demorepos/z/z.sh
``` 
- step04 保存上面的 z.sh 的命令路径做 别名映射

- step05 验证

- step06 我要的是 "j" 而不是 "z"

## bash美化

### 窗口大小调整

- 拖拽bash窗口到你想要的尺寸
- gitbash 顶部右键 options
- 选中 window => current size

### 字体设置

- https://github.com/powerline/fonts/tree/master/SourceCodePro 挨个下载 下载完成后点击文件 提示你安装
- 我这里偷懒了 我就 gitbash 顶部右键 options
  - text => select 选的 "Consolas"
  - text => show bold as font  勾选
  - text => show bold as color 勾选 ,选中Default

### 字符集问题

- 默认的gitbash `ping baidu.com` 显示为乱码
- 通过 顶栏 右键 options
  - text => character set 选 utf-8 `ping baidu.com` 还是乱码
  - 但是你用 curl -L baidu.com 就不是乱码
- ping 命令是win平台的 命令，win命令默认是 "gbk" 
- 推荐字符集设置为 utf-8

## curl命令

- step01 打开 [scoop.sh](https://scoop.sh/)
- step02 windows的 powershell 打开运行`Invoke-Expression (New-Object System.Net.WebClient).DownloadString('https://get.scoop.sh')`
  - 如果报错 建议安装 ss开启 全局模式 代理
- step03 gitbash 里 `which scoop` 显示出路径代表安装成功
- step04 gitbash里 `scoop install curl`

## tree命令

- google [gnutree](http://gnuwin32.sourceforge.net/packages/tree.htm)
- 下载 完整版 Complete package setup文件，然后一路next
- 下载后安装在 `C:\soft\GnuWin32`
- gitbash里 `cd c/soft/GnuWin32/bin` ls 发现有 `tree.exe`
- `vi ~/.bashrc`
添加一句

## 翻译工具

- 前提安装 node / npm
- `npm i -g fanyi`
- 验证`fy hi`

### 如果命令不生效
- 如果提示 commond not found，就需要更新 PATH
- `.bashrc`里添加

## win gitbash常用快捷键

- Ctrl + R 搜索历史，再次 Ctrl + R 切换
- Ctrl + A 行首
- Ctrl + E 行尾
- Ctrl + B 退后
- Ctrl + F 前进
- Ctrl + W 删一个单词
- Ctrl + Kill 干掉这一行
- Ctrl + Cancel 中断
- Ctrl + Go 退出搜索

### fzf

- `scoop install fzf`

// 收集依赖读取代码 看见 import/require 的时候
const code = readFileSync(filepath).toString()

// 重点：正则判断
if(/\.css$/.test(filepath)){
  // 此时 css文件的内容 变成了 js的一个字符串
  code = `
    const str = ${JSON.stringify(code)}
    if(document){
      const style = document.createElement('style')
      style.innerHTML = str;
      document.head.appendChild(style)
    }
    export default str;
  `
}

function transform(code){
  const code2 = doXXX(code)
  return code2
}
module.exports = transform

// or
async function transform(code){
  const code2 = await doXXX(code)
  return code2
}
module.exports = transform

function transform(code){
  return `
    const str= ${JSON.stringify(code)}
    if(document){
      const style = document.createElement('style')
      style.innerHTML = str;
      document.head.appendChild(style)
    }
    export default str;
  `
}
module.exports = transform

if(/\.css$/.test(filepath)){
  // 此时 css文件的内容 变成了 js的一个字符串
  code = require('./loaders/css-loader.js')(code)
}

const code = readFileSync(filepath).toString()
// step01 code 不要原封不动的放到 这里，而是变成es5
const { code: es5Code } = babel.transform(code, {
  presets: ['@babel/preset-env']
})
// 初始化 depRelation[key]
depRelation[key] = { deps: [], code: es5Code }

{
  'index.js': {
    deps: [ 'a.js', 'b.js' ],
    code: '"use strict";\n' +
      '\n' +
      'var _a = _interopRequireDefault(require("./a.js"));\n' +
      '\n' +
      'var _b = _interopRequireDefault(require("./b.js"));\n' +
      '\n' +
      'function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }\n' +
      '\n' +
      'console.log(_a["default"].getB());\n' +
      'console.log(_b["default"].getA());'
  },
  'a.js': {
    deps: [ 'b.js' ],
    code: '"use strict";\n' +
      '\n' +
      'Object.defineProperty(exports, "__esModule", {\n' +
      '  value: true\n' +
      '});\n' +
      'exports["default"] = void 0;\n' +
      '\n' +
      'var _b = _interopRequireDefault(require("./b.js"));\n' +
      '\n' +
      'function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }\n' +
      '\n' +
      'var a = {\n' +
      "  value: 'a',\n" +
      '  getB: function getB() {\n' +
      `    return _b["default"].value + ' from a.js';\n` +
      '  }\n' +
      '};\n' +
      'var _default = a;\n' +
      'exports["default"] = _default;'
  },
  'b.js': {
    deps: [ 'a.js' ],
    code: '"use strict";\n' +
      '\n' +
      'Object.defineProperty(exports, "__esModule", {\n' +
      '  value: true\n' +
      '});\n' +
      'exports["default"] = void 0;\n' +
      '\n' +
      'var _a = _interopRequireDefault(require("./a.js"));\n' +
      '\n' +
      'function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }\n' +
      '\n' +
      'var b = {\n' +
      "  value: 'b',\n" +
      '  getA: function getA() {\n' +
      `    return _a["default"].value + ' from b.js';\n` +
      '  }\n' +
      '};\n' +
      'var _default = b;\n' +
      'exports["default"] = _default;'
  }
}

// a.js代码
import b from './b.js'
const a = {
  value: 'a',
  getB: () => b.value + ' from a.js'
}
export default a

"use strict"; //开启严格模式
// 疑问1
Object.defineProperty(exports, "__esModule", {value: true});
// 疑问2
exports["default"] = void 0; 

// 疑问3
var _b = _interopRequireDefault(require("./b.js"));

// 疑问4
function _interopRequireDefault(obj) { 
  return obj && obj._esModule ? obj : { "default": obj }; 
}

var a = {
  value: 'a',
  getB: function getB() {
    // 疑问5 
    return _b["default"].value + ' from a.js';
  }
};

// 疑问6
var _default = a;
exports["default"] = _default;

var depRelation = [
  {
    key:'index.js',
    deps:['a.js','b.js'],
    code:`字符串code`
  },
  {
    key:'a.js',
    deps:['b.js'],
    code:`字符串code`
  },
  {
    key:'b.js',
    deps:['a.js'],
    code:`字符串code`
  }
]

// 为什么把 depRelation 变成了数组，因为对象{} 没有第一项的概念
// 数组第一项是入口

code2 = `function (require, module, exports) {
  ${code}
}`
// 此时 code2还是字符串
// 把 `code:${code2}`写入到文件
code:function (require, module, exports) {
  // ... code代码
}

// 最终写入的文件效果
var depRelation = [
  {
    key:'index.js',
    deps:['a.js','b.js'],
    code:function (require, module, exports) {
      // ... code代码
    }
  },
  ...
]

const modules = {} // 用于缓存，防止重复加载
execute(depRelation[0].key) // a.js
function execute(key) {
  // 如果已经 require 过，就直接返回上次的结果
  if (modules[key]) { return modules[key] }
  // 找到 a.js 的代码
  var item = depRelation.find(i => i.key === key) 
  // 找不到就报错，中断执行
  if (!item) { throw new Error(`${item} is not found`) }
  // 把相对路径变成项目路径
  var pathToKey = (path) => {...}
  // 创建 require 函数
  var require = (path) => {
    return execute(pathToKey(path))
  }
  // 初始化当前模块
  // modules['a.js'] = { __esModule: true } 辨识我是ES模块
  modules[key] = { __esModule: true }
  // 初始化 module 方便 code 往 module.exports 上添加属性
  //  module = { exports: modules['a.js'] }
  var module = { exports: modules[key] }
  // 调用 code 函数，往 module.exports 上添加导出属性
  // 第二个参数 module 大部分时候是无用的，主要用于兼容旧代码
  item.code(require, module, module.exports)
  // item.code执行的时候，把它导出的内容挂在 module.exports

  // 返回当前模块 modules['a.js']
  return modules[key]
}

var depRelation = [{
  key: "index.js",
  deps: ["a.js", "b.js"],
  code: function (require, module, exports) {
    "use strict";

    var _a = _interopRequireDefault(require("./a.js"));

    var _b = _interopRequireDefault(require("./b.js"));

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

    console.log(_a["default"].getB());
    console.log(_b["default"].getA());
  }
}, {
  key: "a.js",
  deps: ["b.js"],
  code: function (require, module, exports) {
    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports["default"] = void 0;

    var _b = _interopRequireDefault(require("./b.js"));

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

    var a = {
      value: 'a',
      getB: function getB() {
        return _b["default"].value + ' from a.js';
      }
    };
    var _default = a;
    exports["default"] = _default;
  }
}, {
  key: "b.js",
  deps: ["a.js"],
  code: function (require, module, exports) {
    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports["default"] = void 0;

    var _a = _interopRequireDefault(require("./a.js"));

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

    var b = {
      value: 'b',
      getA: function getA() {
        return _a["default"].value + ' from b.js';
      }
    };
    var _default = b;
    exports["default"] = _default;
  }
}]
var modules = {}
execute(depRelation[0].key)
function execute(key) {
  // 如果已经 require 过，就直接返回上次的结果
  if (modules[key]) { return modules[key] }
  // 找到要执行的项目
  var item = depRelation.find(i => i.key === key)
  // 找不到就报错，中断执行
  if (!item) { throw new Error(`${item} is not found`) }
  // 把相对路径变成项目路径
  var pathToKey = (path) => {
    var dirname = key.substring(0, key.lastIndexOf('/') + 1)
    var projectPath = (dirname + path).replace(/\.\//g, '').replace(/\/\//, '/')
    return projectPath
  }
  // 创建 require 函数
  var require = (path) => {
    return execute(pathToKey(path))
  }
  // 初始化当前模块
  modules[key] = { __esModule: true }
  // 初始化 module 方便 code 往 module.exports 上添加属性
  var module = { exports: modules[key] }
  // 调用 code 函数，往 module.exports 上添加导出属性
  // 第二个参数 module 大部分时候是无用的，主要用于兼容旧代码
  item.code(require, module, module.exports)
  // 返回当前模块
  return modules[key]
}

       parse        traverse       generate
code --------> ast  ------->  ast2 -------> code2

import { parse } from "@babel/parser"
import traverse from "@babel/traverse"
import generate from "@babel/generator"

const code = `let a = 'let'; let b = 2`
const ast = parse(code, { sourceType: 'module' })
traverse(ast, {
  enter: item => {
    if (item.node.type === 'VariableDeclaration') {
      if (item.node.kind === 'let') {
        item.node.kind = 'var'
      }
    }
  }
})
const result = generate(ast, {}, code)
console.log(result.code)

import { parse } from "@babel/parser"
import * as babel from "@babel/core"

const code = `let a = 'let';let b = 2; const c = 3`
const ast = parse(code, { sourceType: 'module' })
const result = babel.transformFromAstSync(ast, code, {
  presets: ['@babel/preset-env']
})
console.log(result.code)

import { parse } from "@babel/parser"
import * as babel from "@babel/core"
import * as fs from 'fs'

const code = fs.readFileSync('./test.js').toString()
const ast = parse(code, { sourceType: 'module' })
const result = babel.transformFromAstSync(ast, code, {
  presets: ['@babel/preset-env']
})
fs.writeFileSync('./test.es5.js', result.code)

import a from './a.js'
import b from './b.js'
console.log(a.value + b.value)

function collectCodeAndDeps(filepath: string) {
  const key = getProjectPath(filepath) // 文件的项目路径，如 index.js
  // 获取文件内容，将内容放至 depRelation
  const code = readFileSync(filepath).toString()
  // 初始化 depRelation[key]
  depRelation[key] = { deps: [], code: code }
  // 将代码转为 AST
  const ast = parse(code, { sourceType: 'module' })
  // 分析文件依赖，将内容放至 depRelation
  traverse(ast, {
    enter: path => {
      if (path.node.type === 'ImportDeclaration') {
        // path.node.source.value 往往是一个相对路径，如 ./a.js，需要先把它转为一个绝对路径
        const depAbsolutePath = resolve(dirname(filepath), path.node.source.value)
        // 然后转为项目路径
        const depProjectPath = getProjectPath(depAbsolutePath)
        // 把依赖写进 depRelation
        depRelation[key].deps.push(depProjectPath)

        // 递归依赖收集的核心一句话
        // 递归依赖收集的核心一句话
        // 递归依赖收集的核心一句话
        collectCodeAndDeps(depAbsolutePath)
      }
    }
  })
}

// a.js
import b from './b.js'
const a = {
  value: b.value + 1,
}
export default a

// b.js
import a from './a.js'
const b = {
  value: a.value + 1,
}
export default b

// a.js里
a.value = b.value +1
// b.js里
b.value = a.value +1

// 神经病，a 依赖b，但是 b必须先执行，同时 b又依赖 a
// 运行代码 报错
Maximum call stack size exceeded
// 爆栈了

if (Object.keys(depRelation).includes(key)) {
  console.warn(`duplicated dependency: ${key}`) // 注意，重复依赖不一定是循环依赖
  return
}

// a.js
import b from './b.js'
const a = {
  value: 'a',
  getB: () => b.value + ' from a.js'
}
export default a

// b.js
import a from './a.js'
const b = {
  value: 'b',
  getA: () => a.value + ' from b.js'
}
export default b

//name.js
let name = 'my name is xxx'
exports.name = name

// action.js
let action = 'make webpack'
exports.action = action

// index.js
let action = require('./action.js').action
let name = require('./name.js').name
let msg = `${name} is ${action}`
console.log(msg)

// index.js
function (require, exports, module) {
  let action = require('./action.js').action
  let name = require('./name.js').name
  let msg = `${name} is ${action}`
  console.log(msg)
}

// action.js
function (require, exports, module) {
  let action = 'make webpack'
  exports.action = action
}

// name.js
function (require, exports, module) {
  let name = 'my name is xxx'
  exports.name = name
}

modules = {
  // index.js
  0: function (require, exports) {
    let action = require('./action.js').action
    let name = require('./name.js').name
    let msg = `${name} is ${action}`
    console.log(msg)
  },
  // action.js
  1: function (require, exports) {
    let action = 'make webpack'
    exports.action = action
  },
  // name.js
  2: function (require, exports) {
    let name = 'my name is xxx'
    exports.name = name
  }
}

// 所有的模块归拢到一处
// 用一个 modules 收集
// 过程就是，我们又一个工具 比如叫做 webpack,把我们的代码变成如下内容，然后把每个modules挨个执行一下

// 执行模块返回结果
function exec(id) {
  let fn = modules[id]
  let exports = {}
  fn(require, exports)

  // 浏览器不是 node环境，所以没有 require，我们需要创造一个require
  function require(path) {
    // 根据模块的路径，返回执行的结果
  }
}

// 模块0 是我们的入口文件
exec(0)

modules = {
  // index.js
  0: [
    function (require, exports) {
      let action = require('./action.js').action
      let name = require('./name.js').name
      let msg = `${name} is ${action}`
      console.log(msg)
    },
    // 依赖的模块 路径和 id的映射
    {
      './action.js': 1,
      './name.js': 2
    }
  ],
  // action.js
  1: [
    function (require, exports) {
      let action = 'make webpack'
      exports.action = action
    },
    {}
  ],
  // name.js
  2: [
    function (require, exports) {
      let name = 'my name is xxx'
      exports.name = name
    },
    {}
  ]
}

// 所有的模块归拢到一处
// 用一个 modules 收集
// 过程就是，我们又一个工具 比如叫做 webpack,把我们的代码变成如下内容，然后把每个modules挨个执行一下

// 执行模块返回结果
function exec(id) {
  /*
  mapping 形如
  {
    './action.js': 1,
    './name.js': 2
  }
  */
  let [fn, mapping] = modules[id]
  let exports = {}
  fn && fn(require, exports)

  // 浏览器不是 node环境，所以没有 require，我们需要创造一个require
  function require(path) {
    // 根据模块的路径，返回执行的结果
    return exec(mapping[path])
  }
  return exports
}

// 模块0 是我们的入口文件
exec(0)

# 看见一个模版命令
docker run --name some-nginx -v /some/content:/usr/share/nginx/html:ro -d nginx

# --name给容器起个名字
# -v 挂载的内容
# -d 持久的运行 
# --network=host 容器共享阿里云的端口

ssh blog@dev1
docker run --name nginx1 --network=host -d nginx:1.19.1

# 去安全组开放 80端口
浏览器访问你的 ip 即可

docker run --name nginx1 --network=host -v ~/nginx.conf:/etc/nginx/conf.d/default.conf -d nginx:1.19.1

此时浏览器访问 你的 ip 即可
# 安全组关闭 3000端口
# 开放 80端口

server{
  # ip v4
  listen  80;
  listen [::]:80;
  server_name localhost;

  # 将静态文件转发到静态服务器
  location ~ ^/_next/static/ {
    root /usr/share/nginx/html/;
    expires 30d;
  }

  # 所有的流量导入如下地方
  location / {
    # 反向代理，流量导入这里
    proxy_pass http://0.0.0.0:3000;
  }
}

# 静态文件也需要挂载目录
docker run --name nginx1 --network=host -v ~/nginx.conf:/etc/nginx/conf.d/default.conf -v ~/app/.next/static/:/usr/share/nginx/html/_next/static -d nginx:1.19.1

server{
  # ip v4
  listen  80;
  listen [::]:80;
  server_name localhost;
  gzip on;
  gzip_disable "msie6";

  gzip_comp_level 6;
  gzip_min_length 1100;
  gzip_buffers 16 8k;
  gzip_proxied any;
  gzip_types
      text/plain
      text/css
      text/js
      text/xml
      text/javascript
      application/javascript
      application/x-javascript
      application/json
      application/xml
      application/rss+xml
      image/svg+xml/javascript;

  # 将静态文件转发到静态服务器
  location ~ ^/_next/static/ {
    root /usr/share/nginx/html/;
    expires 30d;
  }

  # 所有的流量导入如下地方
  location / {
    # 反向代理，流量导入这里
    proxy_pass http://0.0.0.0:3000;
  }
}

docker run --name nginx1 --network=host -v ~/nginx.conf:/etc/nginx/conf.d/default.conf -v ~/app/.next/static/:/usr/share/nginx/html/_next/static -d nginx:1.19.1

ssh blog@dev1

vi ~/.bashrc
# 插入一句，后保存
export NODE_ENV=production

# 让这个变动生效
source ~/.bashrc
# 验证
echo $NODE_ENV

# 创建数据库持久化目录
mkdir ~/blog-data

# 这里注意这个 --name my-pg-app 后面会用到,非常重要
docker run --name my-pg-app -v ~/blog-data:/var/lib/postgresql/data --network=host -e POSTGRES_USER=blog -e POSTGRES_HOST_AUTH_METHOD=trust -d postgres:12.2

# 通过id or appname(--name 指定的名字)进入
# docker exec -it <id|appname> bash
# 创建数据库,这里通过这个 [my-pg-app] 进入数据库内部 ,你也可通过 容器id
# 通过应用名进入
docker exec -it my-pg-app bash

# 登录数据库
psql -U blog

# 如果是服务器 生产环境你就这样
CREATE DATABASE blog_production ENCODING 'UTF8' LC_COLLATE 'en_US.utf8' LC_CTYPE 'en_US.utf8';

# 如果是本地你就这样
CREATE DATABASE blog_development ENCODING 'UTF8' LC_COLLATE 'en_US.utf8' LC_CTYPE 'en_US.utf8';

cd ~/
mkdir app
cd app

# 拉代码，前提你配置好 github的ssh key
git clone git@github.com:slTrust/next-demo-2.git .

cd ~/
mkdir shared
vi ormconfig.json

# 内容如下,根据你的 pg设置自行设置
{
  "type": "postgres",
  "host": "localhost",
  "port": 5432,
  "username": "blog",
  "password": "",
  "database": "blog_production",
  "synchronize": false,
  "logging": false,
  "entities": [
    "dist/entity/**/*.js"
  ],
  "migrations": [
    "dist/migration/**/*.js"
  ],
  "subscribers": [
    "dist/subscriber/**/*.js"
  ],
  "cli": {
    "entitiesDir": "src/entity",
    "migrationsDir": "src/migration",
    "subscribersDir": "src/subscriber"
  }
}

# 注意要在项目根目录
cd ~/app
ln -s ~/shared/ormconfig.json

cd ~/app
touch .env.local

# 内容如下
SECRET=c2a85490-cc60-4f21-94e8-8dc5dd3220da

echo '前置准备完成了，启动pg';
docker restart my-pg-app &&
# 推荐这样，因为用户名不一定都叫 blog
cd ~/app/ &&
git pull &&
yarn install --production=false &&
yarn build &&
# 修改补丁, src/entity/User.ts 的补丁
git apply migrate.patch;
# 编译src/migration ,让typeorm 的ts变成 js
yarn compile &&
# 数据库迁移,创建表
yarn m:run &&
# 撤销 patch内容
git reset --hard HEAD &&
# 防止同名应用存在
docker kill my-next-app;
docker rm -f my-next-app;
docker rmi -f hjx/node-web-app;
# docker构建应用
docker build -t hjx/node-web-app . &&
docker run --name my-next-app  --network=host -d hjx/node-web-app &&
echo 'OK!'

# 当访问你机器的 3000 时映射到对应容器的 3000端口
docker run --name my-next-app  -p 3000:3000 -d hjx/node-web-app

# 不再指定 -p 参数
docker run --name my-next-app  --network=host -d hjx/node-web-app

# 前置准备工作
ssh blog@dev1
# clone 我的最新代码
# 分配执行权限
chmod +x ~/app/bin/deploy.sh

# 以后每次改了代码 push之后你就可以这样
ssh blog@dev1 'sh ~/app/bin/deploy.sh'

yarn install --production=false

ssh blog@dev1 "echo hi > /tmp/xxx"

# 你会发现你服务器上的 多了`/tmp/xxx` 文件 内容是 hi

# 项目里声明一个 deploy.sh
# 本地的脚本在服务器端执行
ssh blog@dev1 "bash -s < bin/deploy.sh"

aaa
// bbb
ccc

aaa
bbb
ccc

git diff > migrate.patch

aaa
bbb
ccc

git apply migrate.patch

# 运行后 xxx.js 内容为
aaa
//bbb
ccc

# blog用户登录
ssh blog@dev1

# 进入服务器home目录
cd ~/
# 再次 clone代码
git clone git@github.com:slTrust/next-demo-2.git
# 进入项目根目录
cd next-demo-2

# 切换到我那个时候的代码，以保证同步
git checkout bbc97ab4fc6adf3b93b136bcfeb0ad409c9711e4

# 项目根目录 
touch .env.local
# 内容如下，注意密钥要用你的
SECRET=c2a85490-cc60-4f21-94e8-8dc5dd3220da

# 然后修改 pg数据库的配置 vi ormconfig.json 
把host 改成你机器的 pg数据库信息

"host": "172.17.48.128", // 你机器的ip ifconfig查看
"port": 5432, // docker 启动pg设置的端口
"username": "blog", // pg用户名
"password": "", //  pg密码
"database": "blog_production"

// 13行的
// import {getDatabaseConnection} from '../../lib/getDatabaseConnection';

// 55～59
//const found = await (await getDatabaseConnection()).manager.find(
    User, {username: this.username});
// if (found.length > 0) {
//    this.errors.username.push('已存在，不能重复注册');
// }

# 进入你的项目目录
cd ~/app/next-demo-2/

# 构建应用
docker build -t my-node-app/node-web-app . 

docker run -p 3000:3000 -d my-node-app/node-web-app

# 访问我们的应用，里面报错，但是可以先不管
curl -L localhost:3000

# 查看占用端口
lsof -i :3000
# 杀掉进程
kill pid

history | grep 'docker run'

# 查看我们应用的id
docker ps -a 
# 看log
docker logs id

# log内容
ready - started server on 0.0.0.0:3000, url: http://localhost:3000
error: database "blog_production" does not exist

# 数据库不存在，因为我们没有初始化数据库

# root用户 登服务器
ssh root@dev1
# 设置环境变量
vi ~/.bashrc
export NODE_ENV=production

# 刷新这个文件
source ~/.bashrc

# 测试是否生效
echo $NODE_ENV