Redis

Redis

一. 安装

  • 创建docker-compose.yml文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    version: '3'
    services:
      redis:
        image: 'redis'
        restart: always
        container_name: 'redis',
        ports:
        - 25001:6379
        volumes:
        - /home/docker/redis:/data
        command: ["redis-server", "--requirepass", "123456"] # 123456为设置的默认密码
      
     # docker run -itd --restart=always --name redis -p 25001:6379 -v /home/docker/redis:/data redis redis-server --requirepass 123456

  • 使用 docker-compose up -d运行

二. 常见命令

Redis 命令参考

在容器内运行redis-cli

  1. 在宿主机中运行

    1
    docker exec -it <容器ID/容器名称> redis-cli

  2. 在容器内部运行

    1
    2
    3
    4
    5
    6
    # 进入容器内部
    docker exec -it <容器ID/容器名称> /bin/bash
    # 运行 redis-cli
    redis-cli
    # 登录
    auth <密码>

MongoDB-config

MongoDB 初始化配置及基础操作

==首先先要连接到MongoDB==

  • 连接数据库

    1. 使用mongo连接

    2. 如果是docker启动的MongoDB

      1
      docker exec -it <MongoDB容器名称> mongo

  • 登录帐号

    1
    2
    use admin
    db.auth('root','example')

一. 初始化配置

  1. 新增用户

    官方文档

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    use reporting
    db.createUser(
      {
        user: "reportsUser",
        pwd: passwordPrompt(),  // or cleartext password
        roles: [
           { role: "read", db: "reporting" },
           { role: "read", db: "products" },
           { role: "read", db: "sales" },
           { role: "readWrite", db: "accounts" }
        ]
      }
    )

  2. 管理用户权限

    官方文档

二. 操作

1. 创建数据库

use <数据库名称>

2. 创建用户

1
2
3
4
5
6
7
8
9
10
db.createUser({
	user:'username',
	pwd:'password',
	roles:[
		{
			role:'dbOwner',
			db:'dbname'
		}
	]
})

3. 登录

1
2
3
4
#连接数据库
use <数据库名称>
#登录
db.auth('username','password')

4. 插入数据

== 关系型数据库中的数据表，在MongoDB中称为collection ==

5. 查询数据

db.collection.find()

7. 删除数据

三. 备份

1
2
3
4
# ① 在容器内部生成备份
docker exec -it <mongodb容器名称> mongodump -h localhost -u <管理员帐号> -p <管理员密码> -o <备份保存的路径>
# ② 将容器内部的备份，拷贝到宿主机
docker cp <容器ID>:<备份保存的路径> <宿主机存放备份地址>

四. 还原

1
docker exec -it <mongodb容器名称> mongorestore -h localhost -u <管理员帐号> -p <管理员密码> --dir <存放备份的路径>

MongoDB

MongoDB 安装

一. MacOS

1. 安装

  1. brew tap mongodb/brew

    1
    2
    3

    2. ```bash
       brew install mongodb-community@4.2

2. 运行

  1. 使用mongod运行

    1
    mongod --config /usr/local/etc/mongod.conf

  2. 使用brew services运行

    ==这种方式，会随系统，自动启动==

    1
    brew services start mongodb-community@4.2

3. 连接数据库

1
mongo

二. Docker

  1. 生成docker-compose文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    version: '3.1'
    services:
      mongo:
        image: mongo
        restart: always
        environment:
          MONGO_INITDB_ROOT_USERNAME: root # 初始化默认管理员帐号
          MONGO_INITDB_ROOT_PASSWORD: example # 初始化默认管理员密码
        ports:
          - 27017:27017
        volumes:
          - /home/docker/mongo:/data/db

  2. 运行docker

    1
    docker-compose up -d

Dockerfill-Gitlab-Jenkins

使用Docker+GitLab+Jenkins自动化构建并发布项目

  1. 创建 Gitlab + Jenkins自动化工程

    参考：Jenkins + Gitlab 自动化工程

  2. 在Gitlab项目中新建Dockerfile文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    # build stage
    FROM node:10 as build-stage

    # 设置是谁在维护这个项目
    LABEL maintainer=dragon0072@outlook.com

    # 创建一个工作目录
    WORKDIR /app
    # 把当前文件目录中的文件，copy到镜像中
    COPY . .
    # 安装依赖
    RUN yarn install --registry=https://registry.npm.taobao.org
    # 编译项目
    RUN npm run build

    # production stage
    FROM nginx:stable-alpine as production-stage
    # 将生成的项目文件，拷贝到nginx目录中
    COPY --from=build-stage /app/dist /usr/share/nginx/html
    # 暴露一个端口
    EXPOSE 80
    # 运行nginx
    CMD ["nginx", "-g", "daemon off;"]

  1. 添加.dockerignore文件，将不必要文件，排除

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    # Dependency directory
    # https://www.npmjs.org/doc/misc/npm-faq.html#should-i-check-my-node_modules-folder-into-git
    node_modules
    .DS_Store
    dist

    # node-waf configuration
    .lock-wscript

    # Compiled binary addons (http://nodejs.org/api/addons.html)
    build/Release
    .dockerignore
    Dockerfile
    *docker-compose*

    # Logs
    logs
    *.log

    # Runtime data
    .idea
    .vscode
    *.suo
    *.ntvs*
    *.njsproj
    *.sln
    *.sw*
    pids
    *.pid
    *.seed
    .git
    .hg
    .svn

    注意

    • 如果需要本地化测试

      1
      2
      3
      4
      # 首先，打包成镜像
      docker build -t <自定义镜像名称> .
      # 然后，运行这个镜像
      docker run -itd --name <自定义容器名称> -p 10000:80

  2. 配置Jenkins自动化脚本

    • 进入Jenkins任务

    • 进入配置页面

    • 来到构建选项卡，选择执行shell，并录入脚本

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      # 指定当前为shell脚本
      #!/bin/bash

      # 自定义两个参数
      # ${container_name} 在jenkins任务中配置
      CONTAINER=${container_name}
      PORT=${port}

      # 完成镜像的构建
      docker build --no-cache -t ${image_name}:${tag} .

      # 进行资源处理，判断是否有同名容器，正在运行
      RUNNING=$(docker inspect --format="{{ .State.Running }}" $CONTAINER)

      if [ ! -n $RUNNING ]; then
      	echo "$CONTAINER does not exit"
          return 1
      fi

      if [ "$RUNNING" == "false" ]; then
      	echo "$CONTAINER is not running."
          return 2
      else
      	echo "$CONTAINER is running"
          #delete same name container
          matchingStarted=$(docker ps --filter="name=$CONTAINER" -q | xargs)
          if [ -n $matchingStarted ]; then
          	docker stop $matchingStarted
          fi
          
          matching=$(docker ps -a --filter="name=$CONTAINER" -q | xargs)
          if [ -n $matching ]; then
          	docker rm $matching
          fi
      fi

      echo "RUNNING IS ${RUNNING}"

      # 运行镜像
      docker run -itd --name $CONTAINER -p $PORT:10083 ${image_name}:${tag}
      • 注意
        1. ${container_name},${port},${image_name},${tag}在Jenkins任务配置中，进行配置

    • 来到General选项卡

      • 勾选参数化构建过程
      • 选择添加参数 > 字符参数
      • 根据shell脚本中使用到的参数，进行配置
    1. 来到Gitlab项目，进行一次提交，此时，项目会自动发布到服务器

ssh-login

使用 ssh key 远程登录 Linux服务器

修改 Linux 服务器，远程连接端口

Linux服务器，默认远程连接端口为22

  1. 查看当前ssh服务，运行状态

    1
    service sshd status #systemctl status sshd.service

  2. 修改端口

    • 打开文件

      vi /etc/ssh/sshd_config

    • 找到 # Port 22

    • 删除#号，并修改端口号，为你想要的

  3. 重启服务

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    semanage port -a -t ssh_port_t -p tcp <PORTNUMBER> #如果是ubuntu操作系统，则不需要执行
    # 如果提示 semanage: command not found
    # 则执行 yum whatprovides semanage 反查 semanage 是在哪个包中
    # 然后运行 yum install -y <查到的包> 安装这个包
    # 最后 再重新执行 semanage port -a -t ssh_port_t -p tcp <PORTNUMBER>
    #-------------------------------------------------------------------------------
    # 确认端口是否添加到 semanage中
    semanage port -l |grep ssh
    # 重启 ssh
    service sshd restart #systemctl restart sshd.service

配置 ssh key 登录 Linux 服务器

  1. 在本地生成 ssh key

    ssh-keygen -t rsa -b 4096 -C "<备注>"

  2. 修改本地配置文件

    vi ~/.ssh/config

  3. 添加如下信息

    1
    2
    3
    4
    5
    6
    Host <名称>
      Port <端口号>
      HostName <服务器IP>
      User <登录用户名>
      IdentityFile <生成的ssh key中，私钥的路径>
      IdentitiesOnly yes

  4. 把ssh key中的公钥，录入到服务器的配置文件中

    1
    2
    3
    4
    5
    6
    cd ~/.ssh/ #如果没有这个文件夹，使用 mkdir -p ~/.ssh 创建这个文件夹

    #编辑配置文件
    vi authorized_keys

    #将公钥录入到文件中，并保存

  1. 使用ssh key,远程连接Linux服务器

    1
    ssh <名称>

jenkins&gitlab

Jenkins + Gitlab 自动化工程

  1. 创建Gitlab项目

  2. 进入Jenkins,进入凭据,创建全局凭据

  3. 类型 选择 SSH UserName with private key

  4. 输入UserName和Private Key

    注意：

    • Private Key为秘钥对中的私钥
    • 生成秘钥对ssh-keygen -t rsa -b 4096 -C "<备注>"

  5. 在Gitlab中添加公钥

    • 在项目中添加
      • 进入项目 > 设置 > CI / CD > Deploy Keys
      • 录入名称和公钥
    • 在管理中心中添加
      • 进入管理中心 > 部署密钥
      • 点击新建部署密钥
      • 录入名称和公钥
      • 进入项目 > 设置 > CI / CD > Deploy Keys > 公开访问的部署密钥
      • 把刚添加的密钥点击启用

  6. 复制GitLab项目地址

  7. 进入Jenkins，新建任务

  8. 在源码管理中选择Git

  9. Repository URL中，录入GitLab项目地址

  10. Credentials中，选择刚录入的全局凭据

  11. 配置构建触发器

    • 选择Build when a change is pushed to GitLab.
    • 点击高级，拉到Secret token,点击Generate

    注意：

    1. 在Build when a change is pushed to GitLab.后方，会生成一个Webhook地址

  12. 进入GitLab项目中，在设置 > Webhooks里面，添加Webhook

    • 在URL中，录入在Jenkins中获取的Webhook地址
    • 在Secret Token中，录入在Jenkins中获取的Secret Token
    • 在Trigger中，勾选Push events
    • 取消勾选Enable SSL verification

  13. 进入Jenkins任务中，在构建中，选择执行shell，并录入命令echo 'hello world'

  14. GitLab项目进行一次提交，这时，能看到Jenkins中，自动执行了一次构建，并输出了hello world

Jenkins

Jenkins 使用

一. 系统要求

  1. 最低要求

    RAM > 256M,DISK > 1G

  2. 最小化团队

    RAM > 1G,DISK > 50G+

二. 安装

1. 安装Jenkins

  1. 快捷安装

    1
    docker run --name jenkins -itd -p 8080:8080 -p 50000:50000 jenkins/jenkins:lts

  2. 使用docker-compose安装

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    version: '3'
    services:
      jenkins:
        container_name: 'jenkins'
        image: jenkins/jenkins:lts
        restart: always
        user: jenkins:994 # 这里的 jenkins 要对应当前系统登录用户
        ports:
        - "8080:8080"
        - "50000:50000"
        - "10051:10051"
        volumes: 
        - /home/jenkins/data:/var/jenkins_home
        - /usr/bin/docker:/usr/bin/docker
        - /var/run/docker.sock:/var/run/docker.sock

安装完成后，需要获取jenkins管理员的初始密码

  1. 使用 docker logs -f jenkins 打印日志

  2. 找到日志中输出的 hash密码

2. 进入Jenkins界面

  1. 在文本框中，输入刚刚获取到的 管理员密码，解锁Jenkins
  2. 安装Jenkins插件
    • 插件安装方式有两种：
      • 离线
      • 在线
    • 在线安装插件时，有部分插件需要用到谷歌的服务，这时候，需要配置代理。或者使用离线安装
    • 常用插件
      • GitHub
      • Git client
      • GitLab
      • Gitlab Authentication
      • PAM Authentication
      • Matrix Authorization Strategy
      • Role-based Authorization Strategy
      • LDAP
      • SSH Slaves
      • WMI Windows Agents
      • Build Timeout
      • Dashboard View
      • Folders
      • ThinBackup
      • AnsiColor
      • Build With Parameters
  3. 创建管理员
  4. 配置全局的Jenkins的回调地址(也是Jenkins的登录地址)

三. 备份Jenkins容器内部数据

  1. 使用docker commit进行备份

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    # ① 查找到当前运行的容器
    docker ps | grep jenkins
    # ② commit 当前容器
    docker commit <当前容器的ID> <镜像名称> 
    # ③ 查看镜像
    docker images | grep <镜像名称>
    # ④ 重启镜像
    docker run -itd -v /tmp:/tmp <镜像名称>
    # ⑤ 查看容器名称
    docker ps | grep <镜像名称>
    # ⑥ 使用交互式终端，连接到容器，使用容器内部的cp命令，把容器内部的/var/jenkins_home目录，拷贝到容器的/tmp目录下
    docker exec -it <容器名称> cp -r /var/jenkins_home /tmp
    # ⑦ 停止并删除容器
    docker stop <容器名称> && docker rm <容器名称>

  2. 使用官方文档方式，进行备份

    1
    docker run --rm --volumes-from <需要备份的容器名称> -v /tmp/backup:/backup ubuntu tar cvf /backup/backup.tar /var/jenkins_home

  3. 使用docker cp命令，快速备份

    1
    2
    3
    4
    # ① 查看容器ID
    docker ps | grep <容器名称>
    # ② 复制容器内部的 /var/jenkins_home 目录 到当前的 /tmp/目录下
    docker cp <容器ID>:/var/jenkins_home /tmp/

四. Jenkins 使用 Gitlab 登录

  1. 进入系统控制 > 全局安全配置

  2. 在授权策略中，选中Gitlab Commiter Authorization Strategy

  3. 配置 Gitlab Authorization Settings

    注意：

    ​ 1. Admin User Names 必须和 Gitlab 超级管理员的 UserName对应，否则会丢失超级管理员权限

  4. 在安全域中，选中 Gitlab Authentication Plugin

    注意：

    ​ 1.Client ID和Client Secret要在Gitlab中获取

    ​ 2. GitLab Web URI和GitLab API URI为GitLab链接

  5. 进入Gitlab，选择管理中心，进入应用，并新增应用

    注意：

    1.  重定向URI 为：`<jenkins地址>/securityRealm/finishLogin`

 2.  必须要选中api

  6. 这时，我们会获取到Client ID和 Client Secret

  7. 将得到的Client ID和Client Secret填充到Jenkins的安全域配置中

注意：

​ 1.此时，如果还是无法登陆，需要在Gitlab的 管理中心 > 网络 > 外发请求 中，把<允许Webhook和服务对本地网络的请求>勾选上。

ESLint

ESLint 使用

注意：Node.js version ^6.14 npm version ^3

1. 安装ESLint

  1. 安装 ESLint

    1
    npm i -D eslint

  2. 生成配置文件

    1
    ./node_modules/.bin/eslint --init # 或者 npx eslint init

  3. 运行 ESLint

    1
    ./node_modules/.bin/eslint yourfile.js # 或者 npx eslint yourfile.js

2. ESLint 规则和配置

  1. rules 配置

    rules是配置ESLint的验证规则

    • 以字符串数组的形式，配置各种规则
      • 下标为 0 的字符串，配置当前规则是否启用
      • 下标为 1 的字符串，配置当前规则的逻辑
    • 每个规则，必须配置为下列三个选项中的一个
      • off或0 - 关闭规则
      • warn 或 1 - 开启规则，使用警告级别的错误（不会导致程序退出）
      • error 或 2 - 开启规则，使用错误级别的错误（当被触发时，程序会退出）

  2. extends

    一个配置文件可以被基础配置中的已启用的规则继承。

    • 例如 如果要使用 vue 的默认规则

      • 首先，安装 vue 规则的 ESLint 插件

        使用

        1
        vue add @vue/cli-plugin-eslint

        或

        1
        npm i -D eslint eslint-plugin-vue

      • 然后，在配置文件里面，引用插件

        1
        2
        3
        extends:[
          'plugin:vue/recommended'
        ]

hexo 配置

使用hexo + git 实现简易 Blog

安装 hexo

  1. 全局安装hexo

    1
    npm i hexo-cli -g

  2. 移动到存放 blog 内容的目录

    1
    cd <目录>

  3. 生成 blog 目录

    1
    hexo init <目录名称>

  4. 移动到 blog 目录下

    1
    cd <blog 目录>

  5. 安装 hexo 依赖

    1
    npm i

  6. 启动 hexo 服务，查看效果

    1
    hexo server

安装 hexo-deployer-git

  1. 安装 hexo-deployer-git

    1
    npm install hexo-deployer-git --save

  2. 在 _config.yml 中配置插件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    deploy:
      type: git
      repo: <repository url>
      branch: [branch]
      token: ''
      message: [message]
      name: [git user]
      email: [git email]
      extend_dirs: [extend directory]
      ignore_hidden: false # default is true
      ignore_pattern: regexp  # whatever file that matches the regexp will be ignored when deploying

  3. 发布 blog 

    1
    2
    hexo g
    hexo d

git-lab安装

使用docker 安装git-lab

快捷安装

1
2
3
4
5
6
7
8
9
sudo docker run --detach \ # 后台运行
  --hostname gitlab.example.com \ # 指定域名
  --publish 443:443 --publish 80:80 --publish 22:22 \ # 开放端口： 443（https端口） 80（默认服务访问端口） 22（克隆仓库端口）
  --name gitlab \ # 镜像名称
  --restart always \ #是否自动重启
  --volume $GITLAB_HOME/gitlab/config:/etc/gitlab \
  --volume $GITLAB_HOME/gitlab/logs:/var/log/gitlab \
  --volume $GITLAB_HOME/gitlab/data:/var/opt/gitlab \ # gitlab数据，映射到宿主机
  gitlab/gitlab-ce:latest

使用 docker-compose 安装

  1. 使用官方文档中的方式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    web:
      image: 'gitlab/gitlab-ce:latest'
      restart: always
      hostname: 'gitlab.example.com'
      environment:
        GITLAB_OMNIBUS_CONFIG: |
          external_url 'https://gitlab.example.com'
          # Add any other gitlab.rb configuration here, each on its own line
      ports:
        - '80:80'
        - '443:443'
        - '22:22'
      volumes:
        - '$GITLAB_HOME/gitlab/config:/etc/gitlab'
        - '$GITLAB_HOME/gitlab/logs:/var/log/gitlab'
        - '$GITLAB_HOME/gitlab/data:/var/opt/gitlab'

  1. 使用 github 中的 docker-gitlab 项目进行创建

    • 首先，到docker-gitlab项目下，复制docker-compose.yml 文件中的内容
    • 然后，在文本编辑器中，根据文档提示，配置docker-compose.yml
    • 最后，将配置信息上传到服务器，并使用 docker-compose up -d 运行git-lab服务
    • 如果需要设置git-lab备份超时
      • 在docker-compose.yml文件中，添加 - GITLAB_BACKUP_EXPIRY=604800 #这个参数，是以秒为单位。当前设置的604800，实际是表示7天。

服务成功启动，但访问网页，出现502报错

那大概率为git-lab占用大量cpu，和内存。导致服务器崩溃。

  1. 可尝试启用swap分区进行处理

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    # 1.查看swap分区是否启动（无）
    cat /proc/swaps 

    # 2.创建
    dd if=/dev/zero of=/data/swap bs=512 count=8388616 
    #创建swap大小为bs*count=4294971392(4G)；

    # 3.通过mkswap命令将上面新建出的文件做成swap分区
    mkswap /data/swap 

    # 4.查看内核参数vm.swappiness中的数值是否为0，如果为0则根据实际需要调整成60
    cat /proc/sys/vm/swappiness # 查看
    sysctl -w vm.swappiness=60 # 设置
    # 若想永久修改，则编辑/etc/sysctl.conf文件，改文件中有vm.swappiness变量配置，默认为0

    # 5.启用分区
    swapon /data/swap
    echo “/data/swap swap swap defaults 0 0” >> /etc/fstab

    # 6.再次使用cat /proc/swaps 查看swap分区是否启动
    # 重启gitlab。
  1. 提升服务器配置，最少达到 2核4G

经测试，1核2G的服务器。在启用swap后，等待一段时间，可以访问gitlab。