最近折腾了一把，把本机 Docker Desktop 卸掉，切到了 Colima。

主要原因很简单：公司合规策略不允许继续使用 Docker Desktop。

这篇就当个流水账，给未来的自己留个复盘。

1. 背景

• 公司对 Docker Desktop 的使用有合规限制。
• 本机需要保留容器开发能力（至少能跑 Redis / MariaDB）。
• 目标是：
  • 不用 Docker Desktop
  • 用 Colima + Docker CLI
  • docker compose 可用

2. 卸载 Docker Desktop

先确认：

1
2

brew list | grep -i docker
ps -ef | grep -i docker | grep -v grep

如果还有残留进程，先停掉再卸载。Homebrew 卸载命令：

1

brew uninstall --cask docker-desktop

如果卡在系统权限（com.docker.vmnetd 之类），可以手动处理系统残留：

1

sudo pkill -f com.docker.vmnetd || true

最后再次确认：

1
2

brew list | grep -i docker || echo "已无 docker"
ps -ef | grep -i docker | grep -v grep || echo "已无 docker 进程"

3. 安装 Colima

安装并启动：

1
2

brew install colima docker
colima start --cpu 4 --memory 8 --disk 60

说明：资源参数只需要首次（或改配置时）设置，之后日常 colima start 即可。

确认 context：

1
2

docker context ls
docker context use colima

如果看到当前是 colima *，并且 endpoint 是 ~/.colima/default/docker.sock，就对了。

4. docker compose 报 unknown command 的坑

现象：

1
2

docker compose version
# docker: unknown command: docker compose

原因：安装了 docker-compose 插件，但 Docker CLI 没扫描到 Homebrew 插件目录。

修复：在 ~/.docker/config.json 增加：

1
2
3
4
5

{
  "cliPluginsExtraDirs": [
    "/opt/homebrew/lib/docker/cli-plugins"
  ]
}

验证：

1
2

docker compose version
# Docker Compose version x.x.x

兼容旧命令（可选）：

1
2

# ~/.zshrc
alias docker-compose='docker compose'

5. 防止忘记先启动 Colima

在 ~/.zshrc 里加一个轻量保护：

1
2
3
4
5
6
7

docker() {
  if ! colima status >/dev/null 2>&1; then
    echo "Colima 未启动，先执行: colima start"
    return 1
  fi
  command docker "$@"
}

这样你直接敲 docker ... 时，如果 Colima 没启动，会给明确提示，不会莫名其妙报 socket 错误。

6. Docker Hello 验证启动

迁移完成后，先用一个无状态容器做最小验证，确认 Docker CLI 与 Colima 已正常联通。

1

docker run --rm hello-world

如果输出里看到 Hello from Docker!，说明容器运行链路已经正常。

也可以再补一条查看运行时信息：

1

docker info

7. 小结

这次迁移的关键点其实就三个：

1. 不要混淆 Docker Desktop socket 和 Colima socket。
2. docker compose 不可用时，优先检查插件目录是否被 Docker CLI 扫描。
3. 给 shell 加一个“Colima 未启动提醒”，能省很多排查时间。

到这里，本机容器环境已经完全不依赖 Docker Desktop 了，日常开发够用。

本文基于最新 macOS 行为，整理了一套 仅同步 CLI 工具（如 Codex）的最佳方案，同时避免同步 GUI 应用偏好造成的问题。

Mackup 是什么？

Mackup 可以将应用配置文件同步到云盘，在多台电脑之间保持统一环境。
尤其适合 CLI 工具，例如：

• git
• zsh
• ssh
• Codex（本文示例）

copy 模式 vs link 模式

GUI应用可能有风险

macOS Sonoma 起，系统偏好设置（~/Library/Preferences/*.plist）必须写入本地真实文件，不能放 symlink 后面。
一旦 GUI 应用的 plist 用了 symlink：

• 偏好保存失败

• 自动恢复默认

• 偏好文件损坏

• 应用可能无法启动

终端应用没问题

git,zsh,ssh等终端应用没有问题

这些应用使用的都是普通 JSON / TOML 文件：

1
2

~/.codex/auth.json
~/.codex/config.toml

不属于 plist，不受系统限制，可放心使用 link 模式。

配置 Mackup 的例子

下面先给出最小化、安全的 Codex 配置

mackup配置

编辑：~/.mackup.cfg

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

[storage]
# 使用的存储引擎
engine = icloud
# 存储目录
directory = Mackup

[applications_to_sync]
# 你要同步的应用
codex

[applications_to_ignore]
# 可选：排除你不想同步的应用
# ssh
# git
# vscode

这样能确保：

• Mackup 只管 Codex
• 不会误操作任何 GUI 应用
• 不会触发 Sonoma 的偏好限制

自定义同步文件配置

如果你想让 Mackup 管理更多 Codex 文件（如脚本、文档），可在~/.mackup下面新建文件codex.cfg，内容如下：

1
2
3
4
5
6
7
8

[application]
name = Codex

[configuration_files]
.codex/auth.json
.codex/config.toml
.codex/notify_on_finish.sh
.codex/AGENTS.md

⚠️ 非常重要：

~/.mackup/codex.cfg 会覆盖内置规则，不是追加。
所有要同步的文件必须自己写全。

这样你就可以自由扩展 Codex 的同步文件范围。

使用流程

主力机：首次安装 link 模式

1. 安装 Mackup

1

brew install mackup

2. 编写配置文件：就上面例子中的配置文件

3. 在主力机上初始化：

   1	mackup link install

它会进行如下操作

• 将 Codex 配置复制到云盘
• 删除本地原始文件
• 生成 symlink 指向云端文件

4. 最后检查：

   1	ls -l ~/.codex

应看到：

1
2

auth.json -> ~/Library/.../Mackup/.codex/auth.json
config.toml -> ~/Library/.../Mackup/.codex/config.toml

这说明 link 模式已成功启用。

新电脑：如何恢复

1. 安装 Mackup

   1	brew install mackup

2. 等待 iCloud/Dropbox 同步完整的 Codex 备份

3. 编写配置文件：还是上面例子中的配置文件

   ⚠️Mackup不会同步自己的配置文件
   需要自己处理配置文件的同步

4. 执行恢复

1

mackup link

5. 检查

1

ls -l ~/.codex

应看到：

1
2

auth.json -> ~/Library/.../Mackup/.codex/auth.json
config.toml -> ~/Library/.../Mackup/.codex/config.toml

VIM 是一个功能强大的文本编辑器，但是在某些情况下，鼠标模式可能会导致问题。例如，当你在 VIM 中编辑/选择代码时，鼠标点击可能会导致光标跳转到错误的位置。

为了解决这个问题，你可以禁用 VIM 的鼠标模式。以下是详细步骤：

1. 编辑 VIM 配置文件
   首先，需要编辑你的 VIM 配置文件 ~/.vimrc。
2. 添加配置
   在 ~/.vimrc 文件中添加以下配置：

   1 2 3 4

   " 加载系统默认配置,确保基础功能正常 source $VIMRUNTIME/defaults.vim " 禁用鼠标 set mouse=

   这将禁用 VIM 的鼠标模式。

在某些网络环境中（奇怪的代理工具），22 端口可能被屏蔽，导致无法使用 SSH 进行 Git 推送。

这时，我们可以利用 SSH over HTTPS 的方法，通过 443 端口实现推送。以下是详细步骤：

1. 编辑 SSH 配置文件
   首先，需要编辑你的 SSH 配置文件 ~/.ssh/config。
   将以下配置加到该文件中：

   1 2 3 4

   Host github.com Hostname ssh.github.com Port 443 User git

   也可以使用以下命令一键添加

   1	echo -e "Host github.com\n\tHostName ssh.github.com\n\tPort 443\n\tUser git" >> ~/.ssh/config

   这条命令将指定 GitHub 的主机名为 ssh.github.com， 并将端口设置为 443，用户为 git。

2. 确保配置生效
   配置完成后，可以通过以下命令验证设置是否生效：

   1 2 3

   $ ssh -T git@github.com # Hi USERNAME! You've successfully authenticated, but GitHub does not # provide shell access.

3. 使用 Git 推送
   现在，你可以正常使用 Git 命令进行推送。例如：

   1 2 3

   git add . git commit -m "Your commit message" git push origin main

   由于你已经将 SSH 流量封装在 HTTPS 中，推送操作应该能够顺利完成。

ImageMagick是一个开源的图像处理工具集，能够在命令行下执行多种图像处理操作。以下是一些常见的ImageMagick用法，包括图像格式转换、压缩、裁剪等

安装ImageMagick

1
2
3
4
5
6
7

# Ubuntu
$ sudo apt-get update
$ sudo apt-get install imagemagick
# CentOS/RHEL
$ sudo yum install ImageMagick
# macOS
brew install imagemagick

用法

• 转换为WebP

  1 2 3

  $ convert input.jpg output.webp # GIF动画需要增加-coalesce才能转换 $ convert -coalesce input.gif output.webp

• 有损转换为WebP

  1 2 3

  # 压缩率80 $ convert -quality 80 input.jpg output.webp $ convert -quality 80 -coalesce input.gif output.webp

• 有损转换为JPG

  1 2	# 压缩率80 $ convert -quality 80 input.png output.jpg

粗糙的小公猫,性格温和,随便撸

吃的特别多,是我家的 “没头脑”

漂亮的小母猫,性格高冷,不给撸

挑食又软便,是我家的 “不高兴”

• 首先通过qnapclub安装git命令

• ssh连接威联通

• sudo -i切换到admin(root)用户

• 写一个重载脚本/share/Public/Script/acme/reloadcmd.sh,用于证书申请后重启服务

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  # 建文件夹 $ mkdir -p /share/Public/Script/acme/ # 写入文件 $ cat > /share/Public/Script/acme/reloadcmd.sh <<EOF #!/bin/sh /etc/init.d/Qthttpd.sh stop /etc/init.d/stunnel.sh stop cat /etc/stunnel/backup.cert \ /etc/stunnel/backup.key > \ /etc/stunnel/stunnel.pem /etc/init.d/stunnel.sh start /etc/init.d/Qthttpd.sh start EOF # 授权 $ chmod -R 777 /share/Public/Script/acme/reloadcmd.sh

• 安装**ACME**

  1 2 3 4 5 6 7

  # 在用户目录下操作 $ cd ~ # 克隆 # git clone https://mirror.ghproxy.com/https://github.com/acmesh-official/acme.sh.git $ git clone https://github.com/acmesh-official/acme.sh.git # 安装 $ cd ./acme.sh && ./acme.sh --install

• 执行申请

  按顺序执行以下脚本

  • 切换到admin(root)用户

    1

    $ sudo -i

  • 进入acme目录

    1	$ cd ~/.acme.sh

  • 看情况是不是要升级一下

    1	$ ./acme.sh --upgrade --force

  • 证书颁发机构改为letsencrypt

    • 目前新版本的acme.sh默认证书分发机构为ZeroSSL,有点不好用

      1	$ ./acme.sh --set-default-ca --server letsencrypt

  • 写入参数
    按照自己的情况填写下面的参数

    1 2 3

    $ export CF_Key="example_key" $ export CF_Email="example@example.com" $ export CF_Domain="*.example.com"

  • 注册账号

    1	$ ./acme.sh --register-account -m $CF_Email --force

  • 申请证书

    1	$ ./acme.sh --issue --dns dns_cf -d "$CF_Domain" --force

  • 安装证书(需要调用之前的重载脚本)

    1 2 3 4 5 6

    $ ./acme.sh --install-cert -d "$CF_Domain" \ --cert-file /etc/stunnel/backup.cert \ --key-file /etc/stunnel/backup.key \ --reloadcmd "/share/Public/Script/acme/reloadcmd.sh" \ --log /share/Public/Script/acme/acme.sh.log \ --force

问题

在工作与生活中,我们难免会遇到同时使用多个Git账号的情况

• 私人的项目在Github上托管,使用的user.name配置是Sowevo,使用的user.email是user@sowevo.com

• 公司的项目在Gitlab上托管,使用的user.name配置是lisi,使用的user.email是lisi@gitlab.com

这时就会遇到这样的问题,提交到Gitlab的代码署名确是user@sowevo.com,经常用混

解决方案

按工程配置

git的配置可以放在三个地方：

• /etc/gitconfig 系统配置,对所有用户有效,一般不用

• ~/.gitconfig 用户配置,仅对当前用户生有效

  1 2 3

  # 全局配置 $ git config --global user.name "Sowevo" $ git config --global user.email "user@sowevo.com"

• projectPath/.git/config 项目配置，仅对当前项目生效

  1 2 3

  # 项目配置 $ git config user.name "lisi" $ git config user.email "lisi@gitlab.com"

三种配置的优先级为 项目配置>用户配置>系统配置

此时可以利用项目配置优先的规则,对公司项目单独设置user.name与user.email,但是项目如果比较多的话,每一个都要设置,比较繁琐

可以使用下一种方式配置

按目录配置

Git的2.13.0之后的版本包含了一个新的功能,includeIf配置可以通过路径匹配不同的配置文件

以下操作以macOS为例

• 新建或编辑~/.gitconfig,确保其中存在以下内容

  1 2 3 4 5

  [user] name = sowevo email = user@sowevo.com [includeIf "gitdir:~/git/gitlab/"] path = .gitconfig-work

• 新建~/.gitconfig-work文件

  1 2 3

  [user] name = lisi email = lisi@gitlab.com

此时~/git/gitlab/路径下的git项目全部都会使用.gitconfig-work的配置

此路径下的配置优先级为项目配置>.gitconfig-work配置>用户配置>系统配置

其他路径下的配置优先级为项目配置>用户配置>系统配置

注意:公司项目只能克隆到~/git/gitlab/路径下

Typora支持自动上传图片到图床,需要搭配一些第三方的图床工具

这里选择了PicGo-Core

设置PicGo-Core

• 安装PicGo-Core

  1 2 3 4

  # 依赖node $ npm install picgo -g # or $ yarn global add picgo

• 配置PicGo-Core

  我使用的是腾讯云COS,不同的图床配置不一样,具体参考文档

  1 2 3 4

  # 设置图床 $ picgo set uploader # 选择默认图床 $ picgo use uploader

• 测试上传

  1 2 3 4 5

  # 上传具体路径图片 $ picgo upload /xxx/xxx.jpg # 上传剪贴板里的第一张图片（上传时会将格式转成png） $ picgo upload

设置Typora

Mac设置步骤

• 获取node与picgo的绝对路径

  1 2 3 4

  # 获取node的路径 我的是 /usr/local/bin/node $ which node # 获取picgo的路径 我的是 /usr/local/bin/picgo $ which picgo

• 设置Typora的上传

  • 打开偏好设置–>图像
  • 插入图片时选择上传图片
  • 上传图片设定选择Custom Command
  • 命令填入[your node path] [your picgo-core path] upload,使用上一步获取的路径替换,例如我的是/usr/local/bin/node /usr/local/bin/picgo upload

Winsdows设置步骤

• 设置Typora的上传

  • 打开偏好设置–>图像

  • 插入图片时选择上传图片

  • 上传图片设定选择Custom Command

  • 命令填入picgo upload

外网访问

• 关闭只允许内网访问的设置(去掉勾选)
  
• 防火墙==>端口转发 中添加端口转发,将外网5500应设置OpenWrt的80端口
  
• 通过域名+5500端口即可访问

添加SSL证书

• 编辑uHTTPd的配置文件,打开路由器的SSL 443端口

  1	$ vi /etc/config/uhttpd

  在原有配置 list listen_http ‘0.0.0.0:80’下面加入以下两行

  1 2 3

  # 注意是https list listen_https '0.0.0.0:443' list listen_https '[::]:443'

• 输入以下命令安装 acme.sh

  1	$ curl https://get.acme.sh | sh

  可以看到此时已经添加了定时任务

• 此处使用 cloudflare 接口进行自动认证

  • 获取CF_Email,CF_Key两个参数,并执行以下命令

    1 2	export CF_Email="abcde@126.com" export CF_Key="de6132435csofe45464650w4646464602"

• 输入以下命令,运行acme.sh生成证书,并将生成的证书放到uHTTPd的默认存储位置,最后自动重启uHTTPd

  1	$ /root/.acme.sh/acme.sh --issue --dns dns_cf -d sowevo.com -d *.sowevo.com --keypath /etc/uhttpd.key --fullchainpath /etc/uhttpd.crt --reloadcmd "/etc/init.d/uhttpd restart"

  稍等一会命令执行完成(不同的dns厂商时间会有不同),证书就申请完毕

• 将路由器的443端口映射到外网
  
  家宽的443端口竟然没有封,就先使着吧…

Docker Compose

简介

Docker

DockerFile build run 手动操作,单个容器!

微服务,服务多,相互依赖

使用Docker Compose来高效管理,定义多个容器

• 官方介绍

  定义运行多个容器

  使用yaml配置文件

  所有环境都可以使用

==就是批量容器编排==

安装

1
2
3
4

# 要去git上确认下最新的版本
$ sudo curl -L "https://github.com/docker/compose/releases/download/1.27.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
# 加上权限
$ sudo chmod +x /usr/local/bin/docker-compose

初体验!

官方的例子

1. 创建文件夹

   1 2	$ mkdir composetest $ cd composetest

2. 新建一个app.py文件

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

   import time import redis from flask import Flask app = Flask(__name__) cache = redis.Redis(host='redis', port=6379) def get_hit_count(): retries = 5 while True: try: return cache.incr('hits') except redis.exceptions.ConnectionError as exc: if retries == 0: raise exc retries -= 1 time.sleep(0.5) @app.route('/') def hello(): count = get_hit_count() return 'Hello World! I have been seen {} times.\n'.format(count)

3. 新建一个requirements.txt文件

   1 2	flask redis

4. 创建Dockerfile文件

   1 2 3 4 5 6 7 8 9 10

   FROM python:3.7-alpine # 从Python3.7映像开始构建 WORKDIR /code # 将工作目录设置为/code ENV FLASK_APP=app.py # 设置flask使用的环境变量 ENV FLASK_RUN_HOST=0.0.0.0 RUN apk add --no-cache gcc musl-dev linux-headers # 安装gcc和其他依赖项 COPY requirements.txt requirements.txt RUN pip install -r requirements.txt # 使用requirements安装依赖 EXPOSE 5000 # 监听5000端口 COPY . . CMD ["flask", "run"] # 执行flask命令

5. 创建docker-compose.yml文件

   1 2 3 4 5 6 7 8

   version: "3.9" services: web: build: . ports: - "5000:5000" redis: image: "redis:alpine"

6. 使用compose构建并运行你的app

   1 2 3

   # 如果compose文件名不是标准的docker-compose.yml,可以使用-f指定文件 # docker-compose -f docker-compose-dev.yml up $ docker-compose up

7. 使用compose停止你的app

   1	$ docker-compose down

都干了些什么

1. 根据Dockerfile构建镜像,下载镜像
2. 容器名称的的处理
3. 新建一个网络给这个项目使用

配置文件的编写

官方文档链接

瞅瞅开源项目的docker-compose.yml文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

version: "3.9"           # 1.compose版本
#======================================    
services:                # 2.服务
  web:                   #   服务名
    build: .             #   服务构建目录,会在这个目录下找Dockerfile开始构建
    ports:               #   端口映射
      - "5000:5000" 
    depends_on:          #   多个服务依赖的情况,被依赖的会先启动
      - redis            #   web依赖redis
    environment:         #   一些环境变量
      RACK_ENV: development
      SHOW: 'true'  
  redis:
    image: "redis:alpine" # 指定一个镜像
    expose:              # 暴露一些端口
      - "3000"
      - "8000"
#======================================
networks:               # 3.其他配置
  frontend:
  backend:
volumes:
  db-data:    

再体验-WordPress

部署WordPress

1. 建个文件夹

   1	$ cd my_wordpress/

2. 编写docker-compose.yml文件

   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

   version: '3.3' services: db: image: mysql:5.7 volumes: - db_data:/var/lib/mysql restart: always environment: MYSQL_ROOT_PASSWORD: somewordpress MYSQL_DATABASE: wordpress MYSQL_USER: wordpress MYSQL_PASSWORD: wordpress wordpress: depends_on: - db image: wordpress:latest ports: - "8000:80" restart: always environment: WORDPRESS_DB_HOST: db:3306 WORDPRESS_DB_USER: wordpress WORDPRESS_DB_PASSWORD: wordpress WORDPRESS_DB_NAME: wordpress volumes: db_data: {}

3. 启动项目

   1 2	# 后台那运行 $ docker-compose up -d

再再体验-SpringBoot

1. SpringBoot写个项目

2. 编写Dockerfile

   1 2 3 4 5

   FROM java:8 COPY ./target/*.jar /app.jar EXPOSE 8080 CMD ["--server.port=8080"] ENTRYPOINT ["java","-jar","/app.jar"]

3. 编写docker-compose.yml文件

   1 2 3 4 5 6 7 8 9 10

   version: "3.9" services: spring-boot: build: . ports: - "8080:8080" depends_on: - redis redis: image: redis

4. 启动

   1 2	# 后台运行 $ docker-compose up -d

Docker Swarm

搞几台服务器

搞4台(1核2G)

并安装Docker

工作模式

Swarm 两种角色

Manager：接收客户端服务定义，将任务发送到worker节点；维护集群期望状态和集群管理功能及Leader选举。默认情况下manager节点也会运行任务，也可以配置只做管理任务。

Worker：接收并执行从管理节点分配的任务，并报告任务当前状态，以便管理节点维护每个服务期望状态。

搭建集群

使用Docker Swarm命令

1. 初始化一个manager节点

   1 2 3 4 5 6 7 8 9

   # 初始化一个管理节点 $ docker swarm init --advertise-addr=172.17.88.237 Swarm initialized: current node (84jg51t5nr7ywlqku2uwpkcm3) is now a manager. To add a worker to this swarm, run the following command: docker swarm join --token SWMTKN-1-55o9kohbport6z73roe1m0532kl55ihc712tt6nrd1mupt0n3q-axx5fxz310o6t237m7dbxvt52 172.17.88.237:2377 To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.

2. manager节点生成token

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   # 生成加入工作节点(worker)的token,会直接输出可用的命令,人性化 $ docker swarm join-token worker To add a worker to this swarm, run the following command: docker swarm join --token SWMTKN-1-55o9kohbport6z73roe1m0532kl55ihc712tt6nrd1mupt0n3q-axx5fxz310o6t237m7dbxvt52 172.17.88.237:2377 #===# # 生成加入管理节点(manager)的token,会直接输出可用的命令,人性化 $ docker swarm join-token manager To add a manager to this swarm, run the following command: docker swarm join --token SWMTKN-1-55o9kohbport6z73roe1m0532kl55ihc712tt6nrd1mupt0n3q-brfqx08svxov16vbdi4jolpmc 172.17.88.237:2377

3. 其他节点加入

   1 2	# 根据token的不同注册过去会有不同的权限~ $ docker swarm join --token SWMTKN-1-55o9kohbport6z73roe1m0532kl55ihc712tt6nrd1mupt0n3q-axx5fxz310o6t237m7dbxvt52 172.17.88.237:2377 --advertise-addr=192.168.32.32

命令的相关用法

1
2
3
4
5
6
7
8
9
10
11
12

$ docker swarm COMMAND
#    ca              
#    init                       初始化swarm集群
#          --advertise-addr     <ip|interface>[:port]
#                               广播地址,本机的IP地址
#    join                       加入swarm集群
#    join-token                 (worker|manager)
#                               生成一个加入的令牌,指定令牌的类型,其他机器加入集群时需要
#    leave                      离开swarm集群
#    unlock      
#    unlock-key  
#    update      

Raft协议

Raft协议:保证大多数管理节点(manager)存活,集群才能可用

当只有两台管理节点(manager)时,如果挂掉一个,会导致集群不可用

所以一个高可用的Swarm集群至少要有3台管理节点(manager),一台工作节点(Worker)

Swarm集群中运行项目

docker service

• 与docker的区别

  • docker run :容器启动,不具有扩容容器的功能

  • docker service :服务启动,具有扩容功能,滚动更新

• docker service create部署服务

  1 2 3

  # --name 服务名 -p 端口映射 # 部署后四个服务的8080端口都可以访问到这个服务...厉害了我的哥 $ docker service create -p 8080:80 --name my-nginx nginx

• docker service ps查看服务

  1 2 3 4 5 6 7

  # 查看某个服务运行状态 # docker service ps 服务名 $ docker service ps my-nginx # 查看已经在运行的服务 $ docker service ls

• docker service scale服务扩缩容

  1 2 3 4

  # 将my-nginx服务扩容到3个节点 $ docker service update --replicas 3 my-nginx # 两个命令等价 $ docker service scale my-nginx=1

  服务集群中的任意节点都可以访问,有多个副本可以动态伸缩,实现服务的高可用

• docker service rm服务删除

  1 2	# 讲一个服务删除 $ docker service rm my-nginx

总结

• swarm:集群的管理和编排.Docker开一初始化一个swarm集群,其他节点可以以Manager或者Worker身份加入进来
• Node:就是一个Docker节点,多个节点组成一个集群
• Services:任务,可以在管理节点或者工作节点来运行,是核心,用户访问的.
• task:容器内的命令

命令=>管理=>API=>调度=>工作节点(创建Task容器,维护运行)

DockerStack

Dockercompose的集群版

1
2
3
4

#单机
$ docker-compose up -d workpress.yaml
#集群
$ docker stack deploy workpress.yaml

Docker Secret

安全,配置密码加密证书

Docker Config

配置

Docker概述

Docker为什么会出现?

环境配置的难题:开发环境,测试环境,模拟环境

开发者常常会说:它在我的机器可以跑了(It works on my machine),言下之意就是,其他机器很可能跑不了.

安装的时候,可不可以把原始环境一模一样地复制过来.

Docker针对上面的问题,提出了解决方案

通过隔离机制将服务器压榨到极致

Docker的历史

2010年,几个年轻人开了家公司dotCloud

做一些pass的云计算技术,容器的技术

他们的技术命名为Docker

后来干不下去了…要倒闭

2013年Docker就开源了,就火了

2014年4月9日Docker1.0发布了

为什么这么火🔥?十分的轻巧!

容器技术之前,都是用的VMware虚拟机,十分笨重

Docker容器,也是一种虚拟机

Docker是基于Go语言开发的

官网https://www.docker.com/

文档https://docs.docker.com/

仓库https://hub.docker.com/

Docker能干啥!

• 虚拟机技术缺点:

  1. 资源占用多
  2. 冗余步骤多
  3. 启动慢

• 容器技术

  • 容器化技术模拟的不是一台完整的电脑

• Docke与虚拟机技术的不同

  • 传统虚拟机:虚拟一堆硬件,运行一个完整的系统,然后再这个系统上安装和运行软件
  • Docker容器:直接使用宿主机的内核,容器没有自己的内核
  • 每个容器间是相互隔离的,没个容器都都有一个自己的文件系统

DevOps(开发,运维)

应用更快的交付和部署

传统:一堆帮助文档,安装程序

Docker:打包镜像,发布测试,一键运行

更便捷的升级和扩缩容

使用了Docker后,项目部署就像搭积木

项目打包为一个镜像,直接在服务器A,服务器B上部署

更简单的系统运维

容器化之后,开发,测试,环境高度一致

更高效的计算资源利用

Docker是内核级的虚拟化,可以在一个物理机上运行很多实例!服务器的性能被压榨到极致!

Docker 的安装

Docker的基本组成

• 镜像(Image):
  • Docker镜像相当于一个模板,可以通过这个模板来创建容器,镜像==>run==>容器,通过一个镜像可以常见多个容器
• 容器(container)
  • Docker利用容器技术,独立运行一个或者一组应用,通过镜像来创建的
  • 启动,停止,删除等命令
  • 可以理解为一个建议的linux系统
• 仓库(repository)
  • 仓库就是存放镜像的地方
  • 仓库分为公有仓库和私有仓库
  • 默认是国外的仓库,可以配置为国内的镜像

安装

• 安装

  1	$ curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun

  安装完成后，Docker 服务将会自动启动。输入下面的命令来验证：

  1	$ systemctl status docker

  查看安装的Docker的版本

  1	$ docker version

• Zsh插件的使用

  1. 确认安装了Zsh

  2. 修改~/.zshrc文件

  3. 找到插件配置项plugins=()，增加docker docker-compose两个插件

  4. source ~/.zshrc

• 使用

  • 运行hello-world

    1	$ docker run hello-world

  • 查看安装的镜像

    1 2 3

    $ docker images REPOSITORY TAG IMAGE ID CREATED SIZE hello-world latest bf756fb1ae65 11 months ago 13.3kB

容器加速镜像

1
2
3
4
5
6
7
8
9
10
11
12
13
14

$ mkdir -p /etc/docker

$ cat > /etc/docker/daemon.json <<EOF
{
  "registry-mirrors": [
   "https://ro9g7idi.mirror.aliyuncs.com"
  ]
}
EOF

$ systemctl daemon-reload
$ systemctl restart docker

# 腾讯云可以用这个   https://mirror.ccs.tencentyun.com 地址

底层原理

Docker是怎么工作的

Docker是一个Client-Server(C/S)结构的系统,Docker的守护进程运行在主机上,通过Socket等方式从客户端访问

Server收到Client的命令,就会执行这个命令

默认我们安装的Docker包含了服务端与客户端,所以我们在同一台服务商的操作也是经过客户端==>服务端这个过程的

我们可以在本机安装一个客户端==>远程连接远程服务器上的docker服务端

Docker为什么比VM块?

1. Docker比虚拟机有着更少的抽象层

2. Docker利用的是宿主机的内核,VM是需要Guest OS

​ 新建一个容器的时候,Docker不需要像VM一样重新加载一个操作系统内核,避免引导

Docker的常用命令

帮助命令

1
2
3

$ docker version  # 显示docker的版本
$ docker info     # 显示docker的系统信息
$ docker help     # 帮助命令

镜像命令

• dokcer images: 查看本地主机上的镜像

1
2
3
4
5
6
7

$ dokcer images   # 查看本地主机上的镜像
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    bf756fb1ae65   11 months ago   13.3kB
# 选项:
#  -a, --all             显示所有镜像,（默认隐藏中间镜像）
#  -f, --filter filter   根据提供的条件过滤输出
#  -q, --quiet           仅显示ID

• docker search:搜索镜像

1
2
3
4
5
6
7

$ docker search nginx
NAME                               DESCRIPTION                                    STARS     OFFICIAL   AUTOMATED
nginx                              Official build of Nginx.                       14198     [OK]       
jwilder/nginx-proxy                Automated Nginx reverse proxy for docker con…  1932                 [OK]              
# 选项:
#  -f, --filter filter   根据过滤条件进行过滤
#      --limit int       一页显示多少条

• docker pull:下载镜像

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 可以指定docker 镜像的版本 
# docker pull mysql:5.7.9
# 如果不写tag,默认就是latest
$ docker pull mysql
Using default tag: latest
latest: Pulling from library/mysql
6ec7b7d162b2: Pull complete 
fedd960d3481: Pull complete 
7ab947313861: Pull complete 
64f92f19e638: Pull complete 
3e80b17bff96: Pull complete 
014e976799f9: Pull complete 
59ae84fee1b3: Pull complete 
ffe10de703ea: Pull complete 
657af6d90c83: Pull complete 
98bfb480322c: Pull complete 
6aa3859c4789: Pull complete 
1ed875d851ef: Pull complete 
Digest: sha256:78800e6d3f1b230e35275145e657b82c3fb02a27b2d8e76aac2f5e90c1c30873
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest

• docker rmi:删除镜像

1
2
3
4
5

# 两种形式
# docker rmi 镜像id 
# docker rmi 镜像名:版本号 
$ docker rmi a347a5928046
$ docker rmi hello-world:latest 

容器命令

• docker run:新建容器并启动

  1 2 3 4 5 6 7 8 9 10 11 12

  $ docker run [可选参数] images # 参数说明 --name="name" 容器名称 tomcat01,mysql3306,用来区分容器 -d后台方式运行 -p指定容器的端口 -p ip:主机端口:容器端口 -p 主机端口:容器端口(常用的) -p 容器端口 -p 指定随机端口 -i 以交互模式运行容器,通常与 -t 同时使用 -t 为容器重新分配一个伪输入终端,通常与 -i 同时使用 --rm 用完就删除,一般用来测试

  测试启动容器

  1 2	# 启动centos容器,基础版本,很多命令都是不完善的 $ docker run -it centos /bin/bash

• docker ps列出所有正在运行的容器

  1 2 3 4 5

  $ docker ps # 参数说明 -a 显示所有容器,包括没有在运行的容器 -n=2 显示返回条数 -q 只显示容器的编号

• docker rm删除容器

  1 2 3

  $ docker rm 容器id # 删除指定的容器 # 参数说明 -f 强制删除

• 启动和停止容器

  1 2 3 4

  $ docker start 容器id # 启动容器 $ docker stop 容器id # 停止容器 $ docker restart 容器id # 重启容器 $ docker kill 容器id # 强制停止容器

组合命令(删库跑路)

• 列出所有容器id

  1	$ docker ps -aq

• 停止所有的容器

  1	$ docker stop $(docker ps -aq)

• 删除所有的容器

  1	$ docker rm $(docker ps -aq)

• 删除所有的镜像

  1	$ docker rmi $(docker images -q)

• 组合删库跑路

  1	$ docker stop $(docker ps -aq) && docker rm $(docker ps -aq) && docker rmi $(docker images -q)

常用其他命令

• docker stats 查看容器使用资源情况

  1 2 3 4 5 6 7 8

  # 返回容器资源使用情况,一秒刷新一次 $ docker stats # 返回容器资源使用情况,不刷新 $ docker stats --no-stream # 返回容器资源使用情况,已经停掉的也显示 $ docker stats -a # 返回指定容器资源使用情况 $ docker stats 容器id

• 后台启动容器**-d**

  1 2	# -d 后台启动 $ docker run -d centos

• docker logs查看日志

  1 2 3 4 5 6 7

  $ docker logs -tf --tail 10 容器id # docker logs [OPTIONS] CONTAINER # OPTIONS说明： -f 跟踪日志输出 -t 显示时间戳 --since 显示某个开始时间的所有日志 --tail 仅列出最新N条容器日志

• docker top查看容器中的进程信息

  1 2	# docker top 容器id $ docker top 919121a5a1a6

• docker inspect 查看容器的元数据

  1 2	# docker inspect 容器id $ docker inspect 919121a5a1a6

• 进入当前正在运行的容器

  • 通常都是后台运行的,需要进入容器,修改配置之类的

  • 方式一docker exec

    1 2 3

    # 命令 # docker exec -it 容器id /bin/bash $ docker exec -it 919121a5a1a6 /bin/bash

  • 方式二docker attach

    1 2 3

    # 命令 # docker attach 容器id $ docker attach 919121a5a1a6

  • 两种方式的区别

    • docker exec 在容器中启动新的终端
    • docker attach 进入容器正在执行命令的那个终端.

• docker cp从容器拷贝文件到主机上

  1 2 3 4 5 6

  # docker cp 容器id:容器内的文件名 宿主机上的文件名 $ docker cp 919121a5a1a6:/root/123456.txt /root # docker cp 宿主机上的文件名 容器id:容器内的文件名 $ docker cp /root/123456.txt 919121a5a1a6:/root

不常用其他命令

• docker network对网络的相关操作

  1 2 3 4 5 6 7 8 9 10 11 12

  $ docker network ls # 选项: # connect 将容器连接到网络 # create 新建一个网络 # --driver 网络类型,默认是bridge桥接 # --subnet 子网掩码 # --gateway 网关 # disconnect 断开容器与网络的连接 # inspect 显示一个或多个网络的详细信息 # ls 列出网络 # prune 删除所有未使用的网络 # rm 删除一个或多个网络

• docker tag 对已经存在的镜像添加标签

  1 2	# docker tag 已存在的镜像id dockerhub用户名/镜像名:TAG $ docker tag 69b72121b45e sowevo/diytomcat:1.0

• docker login登录命令:登录到dockerHub,可以发布自己的镜像了~

  1 2 3 4

  $ docker login 选项: -p, --password 密码 -u, --username 账号

• docker save镜像导出成文件

  1 2	# docker save 镜像id -o 保存的文件名 $ docker save sowevo/diytomcat:1.0 -o diytomcat.tar

• docker load从文件导入镜像

  1 2	# docker load -i 遇到导入的文件名 $ docker load -i diytomcat.tar

案例

nginx

1
2
3
4
5

# docker run -d -p 1234:80 --name nginx-1234 nginx
# -d 后台运行
# -p 端口映射
# --name nginx-1234 容器的名称
$ docker run -d -p 1234:80 --name nginx-1234 nginx

tomcat

1
2
3
4
5

# docker run -it -p 8080:8080 --name tomcat8080 tomcat
# -it 交互式启动
# -p 端口映射
# --name tomcat8080 容器的名称
$ docker run -it -p 8080:8080 --name tomcat8080 tomcat

elasticsearch

1
2
3
4
5
6

# docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.10.1
# -d  后台运行
# -p  端口映射,有两个
# -e  镜像的环境参数 具体由镜像来指定,看下镜像的文档
# --name elasticsearch 容器的名称
$ docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e "ES_JAVA_OPTS=-Xms64m -Xmx512m" elasticsearch:7.10.1

总结

可视化

Prtainer

• 安装

  1	$ docker run -d -p 8000:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

• 用的比较少

Rancher

Docker镜像

镜像是什么

镜像是一种轻量级.可执行的独立软件,用来打包运行环境和基于运行环境开发的软件,它包含运行某个软件所需的所有内容,包括代码,运行时,库,环境和配置文件

所有的应用,直接打包Docker镜像,就可以直接跑起来

如何得到镜像

• 从远程仓库下载
• 从别处拷贝
• 自己制作一个镜像Dockerfile

Docker镜像加载原理

UnionFS联合文件系统

我们下载的时候看到的一层层就是这个!
UnionFS (联合文件系统) : Union文件系统( UnionFS )是-种分层、轻量级并且高性能的文件系统,它支持对文件系统的修改作为一次提交来-层层的叠加,同时可以将不同录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是Docker镜像的基础。镜像可以通过分层来进行继承,基于基础镜像(没有父镜像)，可以制作各种具体的应用镜像。
特性: 一次同时加载多个文件系统,但从外面看起来,只能看到一个文件系统,联合加载会把各层文件系统叠加起来,这样最终的文件系统会包含所有底层的文件和目录

Docker镜像加载原理

docker的镜像实际上由一层层的文件 系统组成 ，这种层级的文件系统UnionFS。

bootfs(boot file system)主要包含bootloader和kernel,bootloader主要是引导加载kernel, Linux刚启动时会加载bootfs文件系统,在Docker镜像的最底层是bootfs.这一层与我们典型的Linux/Unix系统是一样的 ,包含boot加载器和内核.当boot加载完成之后整个内核就都在内存中了,此时内存的使用权已由bootfs转交给内核,此时系统也会卸载bootfs.
rootfs (root file system) ,在bootfs之上.包含的就是典型Linux系统中的/dev, /proc, /bin, /etc等标准目录和文件.rootfs就是各种不同的操作系统发行版,比如Ubuntu,Centos等等。

对于一个精简的OS,rootfs可以很小,只要包含最基本的命令,工具和程序库就可以,底层直接使用宿主机的kernel,对于不同的linux发行版本,bootfs基本一致,rootfs会有差别,因此可以共用bootfs

分层

Docker镜像由一些松耦合的只读镜像层组成

Docker负责堆叠这些镜像层，并且将它们表示为单个统一的对象。

举一个简单的例子.

commit提交镜像

1
2
3
4
5
6
7
8

# docker commit 将一个容器提交到本地成为一个新的镜像
# 提交到本地镜像库
$ docker commit -m='描述' -a='作者' 容器id 新的镜像名


# 举个例子
# 默认的Tomcat webapp下面是空的,自己放置好内容之后,想要以后每次新建容器都用这个修改过的,可以把当前这个镜像提交到本地镜像库中
# 以后就可以使用这个新提交的镜像运行容器

容器数据卷

什么是容器数据卷

将容器内的目录挂载到宿主机上,容器中的数据可以存储到本地,这就是数据卷.

为了容器数据的持久化和数据同步操作

使用数据卷

命令挂载

• docker run -v 使用命令来挂载

  1 2 3 4 5 6 7

  # docker run it -v 主机目录:容器目录 镜像名称 # 两个文件夹互相同步 # -v # -v 容器内路径 匿名挂载 # -v 卷名:容器内路径 具名挂载 # -v 容器外路径:容器内路径 指定路径挂载,与具名挂载的区别是,开头是/ $ docker run -it -v /root/test:/root ubuntu

• 具名挂载和匿名挂载

  挂载的三种形式

  • 匿名挂载

    -v 容器内路径,卷名是随机hash值

    文件会在/var/lib/docker/volumes/{hash值}/_data 下

    1	$ docker run -it -v /root ubuntu

  • 具名挂载

    -v 卷名:容器内路径

    文件会在/var/lib/docker/volumes/{卷名}/_data 下

    1	$ docker run -it -v 卷名:/root ubuntu

  • 指定路径挂载

    -v 宿主机路径:容器内路径

    文件会在指定的宿主机路径下

    1	$ docker run -it -v /root/test:/root ubuntu

• ==当挂载宿主机不存在的文件时,会将容器中的文件给覆盖成空的==

• 读写权限的控制

  默认建的卷都是可读可写的权限

  1 2 3 4

  # 指定权限rw:可读可写 $ docker run -it -v /root/test:/root:rw ubuntu # 指定权限ro:可读不可写,只有宿主机可以修改,容器内只能读取 $ docker run -it -v /root/test:/root:ro ubuntu

• 例子:Mysql同步数据

  1 2 3 4 5

  # -d 后台运行 # -p 端口 # -v 挂载路径 将mysql的数据目录和配置目录挂载出来,具体要挂载哪些路径,要看镜像的文档 # -e 镜像的环境参数 具体由镜像来指定,看下镜像的文档 $ docker run -d -p 3306:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root --name mysql01 mysql:5.7

DockerFile挂载

DockerFile就是用来构建docker镜像的脚本文件

1
2
3
4

FROM  centos
VOLUME  ["volume01","/volume02"]
CMD  echo "end"
CMD  /bin/bash

Docker中可以指定挂载文件VOLUME,只能匿名挂载

如果启动容器时制定了相同的卷,DockerFile里面的会被覆盖

数据卷容器:–volumes-from

顾名思义,就是从另一个容器当中挂载容器中已经创建好的数据卷

可以做到两个容器之间的容器共享

1
2
3
4
5

# 先建立一个有挂载文件容器
$ docker run --name ubuntu01 -it -v /root/test:/root ubuntu
# 在建立一个容器可以挂载之前容器挂载的卷
$ docker run --name ubuntu02 --volumes-from=ubuntu01 -it ubuntu
$ docker run --name ubuntu03 --volumes-from=ubuntu01 -it ubuntu

可以做到多个容器之间的配置文件信息的传递

DockerFile

Dockerfile介绍

用来构建Docker镜像的文件!是个脚本

构建步骤

1. 编写Dockerfile文件
2. docker bulid 构建成为一个镜像
3. docker run 运行这个镜像
4. docker push 发布这个镜像(Dockerhub,阿里云仓库,私有仓库)

官方镜像很多都是基础包,很多功能没有,我们通常会构建自己的镜像

Dockerfile构建过程

Dockerfile是面向开发的,我们以后发布项目,作镜像,就需要编写Dockerfile文件,这个文件十分简单

docker镜像已经逐渐成为企业交付的一个标准,有必要掌握!

步骤

Dockerfile:构建文件,定义了一切的步骤,源代码

DockerImage:镜像,通过Dockerfile构建生成,最终发布和运行的产品

Docker容器:容器就是镜像运行起来的服务

DockerFile的指令

脚本有很多指令

• 基础知识
  1. 每个指令都是大写
  2. 执行顺序从上到下
  3. # 是注释
  4. 每一个直径都会创建提交一个新的镜像层,并提交

1
2
3
4
5
6
7
8
9
10
11
12
13
14

FROM          # 基础镜像,一切从这里开始
MAINTAINER    # 镜像是谁写的,姓名,邮箱
RUN           # 镜像构建时要运行的命令
ADD           # 添加文件,例如tomcat的压缩包,会自动解压文件
WORKDIR       # 镜像的工作目录
VOLUME        # 挂载的目录
EXPOSE        # 暴露的端口
CMD           # 启动时要运行的脚本,外部指定命令时会被替换,
              # 例如指定了ls,外部启动时拼接-a,会被替换,只剩-a,报错
ENTRYPOINT    # 启动时要运行的脚本,外部指定命令时不会被替换,而是追加
              # 例如指定了ls,外部启动时拼接-a,会被追加,只剩ls -a可以运行
ONBUILD       # 当构建一个被继承DockerFile,这个命令就会被执行,触发指令
COPY          # 类似ADD,将文件拷贝到镜像中
ENV           # 构建的时候设置环境变量

实战测试

DockerHub中99%的镜像是从scratch来的,最基础的镜像

• 构建自己的centos,安装一些依赖

  1. 编写Dockerfile

     1 2 3 4 5 6 7 8 9 10

     FROM centos MAINTAINER sowevo<i@sowevo.com> ENV MYPATH /user/local WORKDIR $MYPATH # 指定工作路径 RUN yum -y install vim # 安装个软件 RUN yum -y install net-tools # 安装个软件 EXPOSE 80 CMD echo $MYPATH CMD echo "---end---" CMD /bin/bash

  2. docker build构建镜像

     1	$ docker build -f myDcokerFile-centos -t sowevo/centos .

  3. 运行这个镜像

     1	$ docker run -it 8410af091bf5 sowevo/centos

• 构建自己的tomcat

  1. 从下载一个JDK和Tomcat开始

  2. 编写DockerFile,最好使用Dockerfile,官方推荐用

     1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

     # 以centos为基础 FROM centos MAINTAINER sowevo<i@sowevo.com> # 环境变量:工作目录 ENV WORKPATH /usr/local # 拷贝帮助文档 COPY README $WORKPATH/README # 拷贝java和tomcat的安装包,会自动解压到指定路径 ADD apache-tomcat-9.0.41.tar.gz $WORKPATH ADD jdk-8u251-linux-x64.tar.gz $WORKPATH # 安装一个vim RUN yum -y install vim # java和tomcat需要的 环境变脸 ENV JAVA_HOME $WORKPATH/jdk1.8.0_251 ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/lib/tools.jar ENV CATALINA_HOME $WORKPATH/apache-tomcat-9.0.41 ENV CATALINA_BASH $WORKPATH/apache-tomcat-9.0.41 ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/lib # 指定工作目录 WORKDIR $WORKPATH # 开放端口 EXPOSE 8080 # 启动时要执行的命令 CMD $CATALINA_HOME/bin/startup.sh && tail -F $CATALINA_HOME/logs/catalina.out

  3. docker build构建镜像

     1 2	# 如果Dockerfile的名字标准的话,可以不写-f 参数 $ docker build -t diytomcat .

  4. 运行这个镜像

     1 2 3 4

     # -d 后台运行 # -p 端口映射 # -v 文件挂载 $ docker run -d -p 8080:8080 --name diytomcat -v /root/dockerfile/tomcat/webapps/test:/usr/local/apache-tomcat-9.0.41/webapps/test -v /root/dockerfile/tomcat/logs:/usr/local/apache-tomcat-9.0.41/logs diytomcat

  5. 项目文件丢进宿主机的/root/dockerfile/tomcat/webapps/test路径即可访问

发布镜像

DockerHub

1. 注册账号

2. 登录

   1	$ docker login

3. 加一个标签

   1 2 3 4

   # 如果镜像标签不对,会被拒绝 # 可以加一个规范的tag # 对已经存在的镜像添加tag 使用tag命令加一个标签 $ docker tag 69b72121b45e sowevo/diytomcat:1.0

4. 提交自己的镜像

   1 2	# 网不好,推不上去,多尝试几次! $ docker push sowevo/diytomcat:1.0

5. 发布成功!

腾讯云镜像仓库

1. 登录腾讯云

2. 找到容器镜像服务,并开通

3. 创建命名空间

   

4. 创建容器镜像

5. 登录腾讯云仓库

   1	$ sudo docker login --username=23642660 ccr.ccs.tencentyun.com

6. 加一个标签

   1	$ sudo docker tag [ImageId] ccr.ccs.tencentyun.com/sowevo/diytomcat:[tag]

7. 提交自己的镜像

   1	$ sudo docker push ccr.ccs.tencentyun.com/sowevo/diytomcat:[tag]

8. 提交成功!

其他镜像仓库

操作类似,都有提供文档

总结

Docker网络

安装docker会自动安装一个虚拟网卡Dokcer0

多个容器不指定网络的话,默认使用连接这个虚拟网卡Docker0路由,docker会给我们分配一个默认的可用的IP

使用docker network查看所有的docker网络

Docker的几种网络模式

• bridge:桥接网络,默认的
• none:不配置网络
• host:主机模式,和宿主机共享网络
• container:容器间网络联通!(用的少)

容器互连

想要实现容器间网络互连的方式

使用**–link**

多个服务间使用服务名进行服务间的网络调用

1
2
3
4
5
6
7

# 先建立一个容器
$ docker run -d -P --name tomcat01 tomcat 
# 在建立一个容器,使用 --link 指定另一个已存在容器
$ docker run -d -P --name tomcat02 --link tomcat01 tomcat 

# 然后第二个容器就可以使用容器名访问第一个容器
$ docker exec -it tomcat02 ping tomcat01

实际上–link命令就是在建立新容器tomcat02的时候,修改新容器的 /etc/hosts文件,给容器tomcat01的ip绑定一个域名,域名是容器名

现在已经不建议使用–link了~

自定义网络

• 使用docker network创建网络

  1 2 3 4 5

  # 创建一个自定义网络 # --driver bridge 网络类型,桥接 # --subnet 10.0.0.0/24 子网掩码 10.0.0.2~10.0.0.255 # --gateway 10.0.0.1 网关 $ docker network create --driver bridge --subnet 10.0.0.0/24 --gateway 10.0.0.1 customnetwork

• 建立容器时指定使用这个自定义网络

  1 2	$ docker run -d -P --name tomcat-net-01 --net customnetwork tomcat $ docker run -d -P --name tomcat-net-02 --net customnetwork tomcat

• 现在两个容器之间可以通过容器名互相访问

网络联通

实际上就是一个容器链接两个不同的网络

相当于现在现实中一台电脑两根网线连接两个路由器

双网卡!

• 将一个容器连接到其他网络

  1 2 3

  # docker network connect 网络名 容器名 $ docker network connect customnetwork tomcat-01 $ docker network connect customnetwork tomcat-02

实战

装一个redis集群

分片+高可用+负载均衡

1
2
3
4
5

flowchart TD
    
    Redis-主-01 <-->  Redis-从-01;
    Redis-主-02 <-->  Redis-从-02;
    Redis-主-03 <-->  Redis-从-03;

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

# 创建网卡
$ docker network create --driver bridge --subnet 10.0.0.0/24 --gateway 10.0.0.1 redis-net

# 使用脚本创建配置文件
for port in $(seq 1 6) ; \
do \
mkdir -p /mydata/redis/node-${port}/conf
touch /mydata/redis/node-${port}/conf/redis.conf
cat >> /mydata/redis/node-${port}/conf/redis.conf<<EOF
port 6379
bind 0.0.0.0
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 10.0.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done

# 启动脚本
$ docker run -d -p 6371:6379 -p 16371:16379 --name redis-1 -v /mydata/redis/node-1/data:/data -v /mydata/redis/node-1/conf/redis.conf:/etc/redis/conf -d --net redis-net --ip 10.0.0.11 redis redis-server /etc/redis/redis.conf
$ docker run -d -p 6372:6379 -p 16372:16379 --name redis-2 -v /mydata/redis/node-2/data:/data -v /mydata/redis/node-2/conf/redis.conf:/etc/redis/conf -d --net redis-net --ip 10.0.0.12 redis redis-server /etc/redis/redis.conf
$ docker run -d -p 6373:6379 -p 16373:16379 --name redis-3 -v /mydata/redis/node-3/data:/data -v /mydata/redis/node-3/conf/redis.conf:/etc/redis/conf -d --net redis-net --ip 10.0.0.13 redis redis-server /etc/redis/redis.conf
$ docker run -d -p 6374:6379 -p 16374:16379 --name redis-4 -v /mydata/redis/node-4/data:/data -v /mydata/redis/node-4/conf/redis.conf:/etc/redis/conf -d --net redis-net --ip 10.0.0.14 redis redis-server /etc/redis/redis.conf
$ docker run -d -p 6375:6379 -p 16375:16379 --name redis-5 -v /mydata/redis/node-5/data:/data -v /mydata/redis/node-5/conf/redis.conf:/etc/redis/conf -d --net redis-net --ip 10.0.0.15 redis redis-server /etc/redis/redis.conf
$ docker run -d -p 6376:6379 -p 16376:16379 --name redis-6 -v /mydata/redis/node-6/data:/data -v /mydata/redis/node-6/conf/redis.conf:/etc/redis/conf -d --net redis-net --ip 10.0.0.16 redis redis-server /etc/redis/redis.conf

# 配置集群
$ docker exec -it redis-1 redis-cli --cluster create 10.0.0.11:6379 10.0.0.12:6379 10.0.0.13:6379 10.0.0.14:6379 10.0.0.15:6379 10.0.0.16:6379 --cluster-replicas 1

这样创建的外网访问有问题…

SpringBoot微服务打包Docker镜像

1. 构建SpringBoot项目

2. 打包应用

3. 编写Dockerfile

   1 2 3 4 5 6 7 8 9 10

   # 以java为基础 FROM java:8 # 复制打包出来的jar文件,名字叫app.jar COPY target/*.jar /app.jar CMD ["--server.port=8080"] EXPOSE 8080 ENTRYPOINT ["java","-jar","/app.jar"]

4. 构建镜像

   1	$ docker build -t docker-test:0.0.1-SNAPSHOT .

5. 发布运行

本地恢复hexo的环境

• 安装nodejs

  1 2 3 4 5 6

  # mac $ brew install node # centos $ yum install -y nodejs # Ubuntu $ apt install nodejs npm -y

• node的国内镜像源配置

  1	$ npm config set registry https://registry.npmmirror.com

• 从git克隆项目文件

  1 2 3

  # 因为使用了子项目管理主题,加上'--recursive'参数 $ git clone --recursive git@github.com:Sowevo/sowevo.github.io.git $ git clone --recursive https://github.com/Sowevo/sowevo.github.io.git

• 进入项目

  1	$ cd ~/sowevo.github.io

• 更新主题子项目

  1 2 3 4 5 6 7 8

  # 进入项目 $ cd ~/sowevo.github.io # 更新子项目的代码 $ git submodule update --init --recursive # 如果有更新,提交一下 $ git add themes/next $ git commit -m "themes submodule updated" $ git push

• 更新升级项目依赖包

  1 2 3 4

  # 进入项目 $ npm i -g npm-check-updates $ ncu -u $ npm install

• 安装相关依赖

  1 2 3 4 5 6 7 8 9 10

  # 安装hexo $ npm install -g hexo-cli # 安装依赖 $ npm install # 安装hexo git 部署插件 $ npm install hexo-deployer-git # 其他插件 $ npm install hexo-generator-sitemap $ npm install hexo-generator-baidu-sitemap $ npm install hexo-generator-feed

• 至此,环境恢复完成,可以开始干活了!!!

• 相关命令

  1 2 3 4 5 6 7 8

  # 新建文章 $ hexo n "我的博客" # 生成静态文件 $ hexo g # 运行服务 $ hexo s # 部署 $ hexo d

• 记得提交hexo分支的源文件

此方法同样适用于

• TEWA-800E

二逼破解

• 进入光猫登录界面
  
• F12进入开发者工具,在Elements中搜索user_name找到这里
• 将元素id改为CUAdmin,此时界面上出现用户名输入框,如图
  
• 切换到Sources标签页,找到submitFrm()函数
  
• 将函数复制出来进行修改,删掉其中的

  1 2 3 4

  if(username.value!='user'){ alert('请输入正确的用户账户!'); return; }

  将其改为

  1 2 3 4 5 6 7 8 9 10 11

  function submitFrm() { with(document.forms[0]) { if ( password.value.length == 0 ) { alert('密码不得为空!'); return; } } document.getElementById('loginfrm').submit(); }

  将修改后的函数输入到Console标签页,回车后执行
• 两个输入框都输入CUAdmin后点击GO登录
  
• 成功进入后台
  

普通破解

• 其实还有简单点的方法…
  打开登陆页,打开开发者工具,切换到Console标签页,输入以下命令

  1 2 3

  document.getElementById('user_name').value = 'CUAdmin'; document.getElementById('password').value = 'CUAdmin'; document.getElementById('loginfrm').submit();

  回车即可,三行命令搞定

文艺破解

• 直接访问http://192.168.1.1/loginUser.htm?username=CUAdmin&password=CUAdmin

安装安装python3可能使用相关软件

1
2

yum groupinstall 'Development Tools'
yum install -y ncurses-libs zlib-devel mysql-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel gcc

安装安装python3

• python官网下载安装包

• 下载最新版源码，使用make altinstall，如果使用make install，在系统中将会有两个不同版本的Python在/usr/bin/目录中。这将会导致很多问题，而且不好处理。

  1 2 3 4 5 6 7

  # 此处以3.6.5为例 wget https://www.python.org/ftp/python/3.6.5/Python-3.6.5.tgz tar -xzvf Python-3.6.5.tgz -C /tmp cd /tmp/Python-3.6.5/ ./configure --prefix=/usr/local make make altinstall

• 更改/usr/bin/python链接,如果有pip也给更改了

  1 2 3 4 5 6 7

  cd /usr/bin mv python python.backup ln -s /usr/local/bin/python3.6 /usr/bin/python ln -s /usr/local/bin/python3.6 /usr/bin/python3 mv pip pip.backup ln -s /usr/local/bin/pip3.6 /usr/bin/pip ln -s /usr/local/bin/pip3.6 /usr/bin/pip3

• 更改yum脚本的python依赖

  1 2	cd /usr/bin ls yum*

• 修改上面命令列出的文件更改以上文件头

  1	#!/usr/bin/python 改为 #!/usr/bin/python2

• 修改gnome-tweak-tool配置文件(如果有的话)

  1 2	vim /usr/bin/gnome-tweak-tool #!/usr/bin/python 改为 #!/usr/bin/python2

• 修改urlgrabber配置文件(如果有的话)

  1 2	vim /usr/libexec/urlgrabber-ext-down #!/usr/bin/python 改为 #!/usr/bin/python2

• 2005年6月,腾讯发布了一款桌面虚拟宠物养成游戏──QQ宠物
• 同年,我第一次接触计算机(去网吧😅),注册了我的第一个QQ账号
• 2008年,家中购置了一台计算机,我开始第一次遇见QQ宠物

从2008年到现在,期间一直断断续续的玩这个游戏,逐渐成为了有百万元宝的大富鹅,研究生毕业的文化鹅,去过世界每一个角落的探险鹅.

虽然依依不舍，但是QQ宠物停运是无法阻拦的事

可怜的小胖鹅开心的吃着宵夜,也许他永远不会知道这是他吃的最后的一顿

吃饱喝足

永别了~~

贴两张照片~

闲来无事,把博客从WordPress迁移到了Hexo

WordPress对Markdown支持不太好,又得要个php服务器支持,费事~~~

Hexo可以直接是用静态页面管理,还是挺简单的

最后,大家一起来

Hello World!

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
41
42
43
44
45

# 确保来源分支代码最新
$ git checkout master
$ git pull

# 确保目标分支代码最新
$ git checkout QC_1916
$ git pull

# 在目标分支上执行操作,禁止快进式合并
$ git merge --no-f origin/master

# 如果有冲突
$ git merge --no-f origin/master
Auto-merging index.html
CONFLICT (content): Merge conflict in Devmngr/app/BP/system/BusCityInfoBP.java
Automatic merge failed; fix conflicts and then commit the result.
# 开始解决冲突
# 查看冲突状态
$ git status
# 开始处理
$ git mergetool

This message is displayed because 'merge.tool' is not configured.
See 'git mergetool --tool-help' or 'git help config' for more details.
'git mergetool' will now attempt to use one of the following tools:
opendiff kdiff3 tkdiff xxdiff meld tortoisemerge gvimdiff diffuse diffmerge ecmerge p4merge araxis bc codecompare emerge vimdiff
Merging:
Devmngr/app/BP/system/BusCityInfoBP.java

Normal merge conflict for 'Devmngr/app/BP/system/BusCityInfoBP.java':
  {local}: modified file
  {remote}: modified file
Hit return to start merge resolution tool (tortoisemerge):

# 输入回车用默认的合并工具
# 在工具中解决冲突

# 在次查看状态确认已解决
$ git status

# 完成合并提交
$ git commit

# 提交到远端
$ git push

使用Beyond Compare作为对比工具

MAC的话要先安装命令行工具

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# Windows需要修改.gitconfig文件 加入如下配置
[diff]
tool = bc4
[difftool "bc4"]
cmd = \"D:/Beyond Compare/BCompare.exe\" \"$LOCAL\" \"$REMOTE\"
[merge]
tool = bc4
[mergetool "bc4"]
cmd = \"D:/Beyond Compare/BCompare.exe\" \"$LOCAL\" \"$REMOTE\" \"$BASE\" \"$MERGED\"
trustExitCode = true

# MAC user目录下的.gitconfig
[diff]
        tool = bcomp
[difftool "bcomp"]
        cmd = \"/usr/local/bin/bcomp\" \"$LOCAL\" \"$REMOTE\"
[difftool]
        prompt = false
[merge]
        tool = bcomp
[mergetool]
        prompt = false
[mergetool "bcomp"]
        cmd = \"/usr/local/bin/bcomp\" \"$LOCAL\" \"$REMOTE\" \"$BASE\" \"$MERGED\"

删除分支

1
2
3
4
5
6
7
8
9

# 查看本地分支
$ git branch
# 删除本地分支
$ git branch -d <BranchName>

# 查看远端分支
$ git branch -a
# 删除远端分支
$ git push origin --delete <BranchName>

获取两个分支的差异文件

1
2

# 比较YD2007,online两个分支的差异文件的列表,记录到文件
$ git diff YD2007 QC_online --stat --stat-name-width=1000 --stat-graph-width=-10 > 123.txt

设置用户名密码