Tabsp's blog

仅使用 443 端口完美配置 Nginx SNI 分流 REALITY&XHTTP、Hysteria 2 及 WEB 网站

Tue, 17 Dec 2024 22:34:00 GMT

背景

上一篇文章介绍了手动安装并配置 Xray 的 REALITY 协议，但是支持 REALITY 协议的 iOS 的客户端太少，所以打算同时安装一个 Hysteria 2 作为补充。目前来看 Xray core 短期内不会支持 Hysteria 2，故考虑使用 nginx 同时反代 Xray 和 Hysteria 2。

正如标题所言，这次我们上点强度，为了达到完美的效果，我们只使用一个 443 端口，实现 nginx 反代 Xray（支持 REALITY&XHTTP）和 Hysteria 2，同时再反代一个 WEB 网站，网站支持 HTTP/2 和 HTTP/3。

流程如下：

┌─────────────┐    ┌────────────────┐     ┌───────────────────┐
│ WEB browser │    │ REALITY client │     │ Hysteria 2 client │
└──────┬──────┘    └───────┬────────┘     └─────────┬─────────┘
       │                   │                        │
       │                   │                        │
       │                   │                        │
       │                   │                        │
       │          ┌────────▼────────┐               │
       └──────────► example.com:443 ◄───────────────┘
                  └────────┬────────┘
                           │
                           │
                       ┌───▼───┐
                       │ Nginx │
                       └───┬───┘
                           │
        ┌──────────────────┼────────────────────────┐
        │                  │                        │
  ┌─────▼──────┐    ┌──────▼───────┐     ┌──────────▼────────┐
  │ WEB server │    │ Xray server │     │ Hysteria 2 server │
  └────────────┘    └──────────────┘     └───────────────────┘

准备工作

一个域名，本文以 example.com 为例，注意自行替换下文所有配置文件中的域名为自己的域名
将 example.com 解析到自己主机，不要开启 CDN
和上一篇文章一样，本文所有操作均基于 root 用户
一些耐心

安装

安装 Nginx

编译安装最新版本 Nginx

wget https://nginx.org/download/nginx-1.26.2.tar.gz

tar -zxvf nginx-1.26.2.tar.gz

cd nginx-1.26.2

apt install gcc make -y
apt install libpcre3 libpcre3-dev zlib1g zlib1g-dev libssl-dev -y

./configure --prefix=/usr/local/nginx --with-http_ssl_module --with-http_v2_module --with-http_v3_module --with-stream --with-stream_ssl_module --with-http_realip_module --with-stream_ssl_preread_module 

make && make install

设置 Nginx 开机启动，新建 /etc/systemd/system/nginx.service，文件内容如下

[Unit]
Description=The NGINX HTTP and reverse proxy server
After=syslog.target network-online.target remote-fs.target nss-lookup.target
After=xray.service

[Service]
Type=forking
ExecStartPre=/usr/local/nginx/sbin/nginx -t
ExecStart=/usr/local/nginx/sbin/nginx
ExecReload=/usr/local/nginx/sbin/nginx -s reload
ExecStop=/bin/kill -s QUIT $MAINPID
PrivateTmp=true

[Install]
WantedBy=multi-user.target

启动 Nginx 服务并将 nginx 加入 PATH：

echo "PATH=$PATH:/usr/local/nginx/sbin" >> ~/.bashrc
systemctl enable nginx
systemctl start nginx

安装 acme 并申请 https 证书

安装 acme 并申请证书，注意更换为自己邮箱并提前设置域名解析，另外还需要临时将默认 nginx 配置的 server_name 改为要申请证书的域名：

curl https://get.acme.sh | sh -s email=youremail@example.com
source ~/.bashrc
acme.sh --issue -d example.com --nginx /usr/local/nginx/conf/nginx.conf

安装证书：

mkdir -p /usr/local/nginx/certs/example.com

acme.sh --install-cert -d example.com \
--key-file       /usr/local/nginx/certs/example.com/cert.key  \
--fullchain-file /usr/local/nginx/certs/example.com/fullchain.cer

安装 Hysteria 2

使用官方脚本一键安装并设置开机启动（注意需要设置 root 为启动用户）：

HYSTERIA_USER=root bash <(curl -fsSL https://get.hy2.sh/)

systemctl enable hysteria-server

安装 Xray

参考上一篇文章安装并设置自动更新 dat。

配置

端口规划：

端口	监听	协议	服务	作用
80	0.0.0.0	HTTP	Nginx	强制重定向至 443
443	0.0.0.0	TCP	Nginx	Xray、HTTP/2 WEB 服务入口
443	0.0.0.0	UDP	Nginx	Hysteria 2、HTTP/3 WEB 服务入口
2024	127.0.0.1	XHTTP	Xray	Xray XHTTP 协议监听端口
3001	127.0.0.1	HTTP	Any WEB service	WEB 服务监听端口，搭建自己的服务
1443	127.0.0.1	TCP	Xray	Xray REALITY 协议监听端口
2443	127.0.0.1	UDP	Hysteria 2	Hysteria 2 监听端口
8443	127.0.0.1	HTTP	Nginx	反代 WEB 服务

配置 Nginx

懒得解释了，自行问 ChatGPT 吧 :D

worker_processes  auto;

error_log  logs/error.log  notice;
pid        logs/nginx.pid;

events {
    worker_connections  1024;
}

stream {
    map $ssl_preread_server_name $backend_name {
        example.com reality_backend;
        default web_backend;
    }

    upstream reality_backend {
        server 127.0.0.1:1443;
    }

    upstream web_backend {
        server 127.0.0.1:8443;
    }

    upstream hysteria_backend {
        server 127.0.0.1:2443;
    }    

    server {
        listen 443;
        listen [::]:443;

        ssl_preread    on;
        proxy_pass     $backend_name;
        proxy_protocol on;
    }

    server {
        listen 443 udp reuseport;
        listen [::]:443 udp reuseport;

        proxy_pass    hysteria_backend;
        proxy_timeout 20s;
    }
}


http {
    server_tokens off;
    include       mime.types;
    default_type  application/octet-stream;
    
    map $http_x_forwarded_for $clientRealIp {
        "" $remote_addr;
        "~*(?P<firstAddr>([0-9a-f]{0,4}:){1,7}[0-9a-f]{1,4}|([0-9]{1,3}\.){3}[0-9]{1,3})$" $firstAddr;
    }

    log_format main '$clientRealIp $remote_addr $remote_user [$time_local] "$request" '
                    '$status $body_bytes_sent "$http_referer" '
                    '"$http_user_agent" $http_x_forwarded_for '
                    '"$upstream_addr" "$upstream_status" "$upstream_response_time" "$request_time" ';
    access_log       logs/access.log  main;

    sendfile          on;
    keepalive_timeout 65;

    gzip       on;
    gzip_types text/plain text/css application/json application/javascript text/xml application/xml;

    server {
        listen 80;
        listen [::]:80;
        return 301 https://$host$request_uri;
    }

    server {
        listen 127.0.0.1:8443 quic reuseport;
        listen 127.0.0.1:8443 ssl proxy_protocol reuseport;

        http2 on;

        set_real_ip_from 127.0.0.1;
        real_ip_header   proxy_protocol;

        ssl_certificate     /usr/local/nginx/certs/example.com/fullchain.cer;
        ssl_certificate_key /usr/local/nginx/certs/example.com/cert.key;

        ssl_protocols             TLSv1.2 TLSv1.3;
        ssl_prefer_server_ciphers on;
        ssl_ciphers               ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305;
        ssl_ecdh_curve            secp521r1:secp384r1:secp256r1:x25519;

        # 替换为自己 XHTTP 的路径，一般为随机字符串，对应下文中 Xray 的配置
        location /<replace-this> {
            grpc_pass grpc://127.0.0.1:2024;
            grpc_set_header Host $host;
            grpc_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }

        location / {
            add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always;
            add_header Alt-Svc 'h3=":443"; ma=86400';

            proxy_set_header   X-Real-IP $remote_addr;
            proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header   Host $host;
            proxy_pass         http://127.0.0.1:3001;
            proxy_http_version 1.1;
            proxy_set_header   Upgrade $http_upgrade;
            proxy_set_header   Connection "upgrade";
        }
    }
}

配置 Xray

与上一篇文章一样，将配置文件中的所有 <replace-this> 替换为自己的配置，不同之处在于这次 reality 回落域名使用的是自己的域名，俗称“自己偷自己”。

{
  "log": {
    "loglevel": "warning",
    "error": "/var/log/xray/error.log",
    "access": "/var/log/xray/access.log" 
  },
  "routing": {
    "domainStrategy": "IPIfNonMatch",
    "rules": [
      {
        "type": "field",
        "protocol": [
            "bittorrent"
        ],
        "outboundTag": "block"
      },
      {
        "type": "field",
        "ip": [
            "geoip:private"
        ],
        "outboundTag": "block"
      },
      {
        "type": "field",
        "ip": [
            "geoip:cn"
        ],
        "outboundTag": "block"
      },
      {
        "type": "field",
        "domain": [
            "geosite:category-ads-all"
        ],
        "outboundTag": "block"
      }
    ]
  },
  "inbounds": [
    {
      "listen": "127.0.0.1",
      "port": 1443,
      "protocol": "vless",
      "settings": {
        "clients": [
          {
            "id": "<replace-this>", // 可以使用 xray uuid 生成，注意保存
            "flow": "xtls-rprx-vision"
          }
        ],
        "decryption": "none",
        "fallbacks": [
          {
            "dest": 2024
          }
        ]
      },
      "streamSettings": {
        "network": "raw",
        "security": "reality",
        "realitySettings": {
          "target": 8443,
          "xver": 1,
          "serverNames": [
            "<replace-this>" // 设置客户端可用的 server name 列表，设置为你自己域名 example.com
          ],
          "privateKey": "<replace-this>", // 可以使用 xray x25519 生成
          "shortIds": [
            ""
          ]
        },
        "rawSettings": {
          "acceptProxyProtocol": true
        }
      },
      "sniffing": {
        "enabled": true,
        "destOverride": [
          "http",
          "tls",
          "quic"
        ]
      }
    },
    {
      "listen": "127.0.0.1",
      "port": 2024,
      "protocol": "vless",
      "settings": {
        "clients": [
          {
            "id": "<replace-this>" // 可以使用 xray uuid 生成，注意保存
          }
        ],
        "decryption": "none"
      },
      "streamSettings": {
        "network": "xhttp",
        "xhttpSettings": {
          "path": "<replace-this>" // 随便输入一个路径，随机字符串即可，注意替换 Nginx 中的反代配置
        }
      },
      "sniffing": {
        "enabled": true,
        "destOverride": [
          "http",
          "tls",
          "quic"
        ]
      }
    }
  ],
  "outbounds": [
    {
      "protocol": "freedom",
      "tag": "direct"
    },
    {
      "protocol": "blackhole",
      "tag": "block"
    }
  ]
}

配置 Hysteria 2

证书复用前文中使用 acme 申请到的证书，并将 Hysteria 2 的伪装（masquerade）设置为自己的网站 https://example.com/，端口跳跃自行查阅官方文档开启。

这里多说一句，Hysteria 2 的伪装原理就是将自己伪装为成标准的 HTTP/3 流量，认证成功流量会通过 Hysteria 2，认证失败就会走伪装的网站。

listen: 127.0.0.1:2443

tls:
  cert: /usr/local/nginx/certs/example.com/fullchain.cer
  key: /usr/local/nginx/certs/example.com/cert.key

auth:
  type: password
  password: "<replace-this>", # 密码，可以使用 xray uuid 生成，注意保存

masquerade:
  type: proxy
  proxy:
    url: https://example.com/
    rewriteHost: true

配置成功后你会发现当启动 hysteria-server 后使用浏览器访问你的网站 https://example.com/ 会显示协议为 h3，关闭 hysteria-server 后再访问网站协议就会变为 h2。

重启所有服务

完成配置后重启所有服务，并检查服务状态和日志是否正常。

systemctl restart nginx
systemctl restart hysteria-server
systemctl restart xray

以上，祝你成功。

手动配置 Xray（vless+reality+vision）代理服务器

Sat, 14 Dec 2024 22:41:00 GMT

依赖

curl
vim

本文所有操作均基于 root 用户。

安装

安装 Xray

bash -c "$(curl -L https://github.com/XTLS/Xray-install/raw/main/install-release.sh)" @ install

配置

Xray 配置

使用 vim 修改 Xray 默认配置文件，默认路径在 /usr/local/etc/xray/config.json，默认内容为 {}。

vim /usr/local/etc/xray/config.json

参考配置：

{
    "log": {
        "loglevel": "warning"
    },
    "routing": {
        "domainStrategy": "IPIfNonMatch",
        "rules": [
            {
                "type": "field",
                "protocol": [
                    "bittorrent"
                ],
                "outboundTag": "block"
            },
            {
                "type": "field",
                "ip": [
                    "geoip:private"
                ],
                "outboundTag": "block"
            },
            {
                "type": "field",
                "ip": [
                    "geoip:cn"
                ],
                "outboundTag": "block"
            },
            {
                "type": "field",
                "domain": [
                    "geosite:category-ads-all"
                ],
                "outboundTag": "block"
            }
        ]
    },
    "inbounds": [
        {
            "tag": "xray-xtls-reality",
            "listen": "0.0.0.0",
            "port": 443,
            "protocol": "vless",
            "settings": {
                "clients": [
                    {
                        "id": "<replace-this>", // 可以使用 xray uuid 生成，注意保存
                        "flow": "xtls-rprx-vision"
                    }
                ],
                "decryption": "none"
            },
            "streamSettings": {
                "network": "tcp",
                "security": "reality",
                "realitySettings": {
                    "dest": "<replace-this>", // 自行设置合适的回落域名，必须带端口，比如：www.example.com:443
                    "serverNames": [
                        "<replace-this>" // 自行设置客户端可用的 server name 列表，例如：www.example.com
                    ],
                    "privateKey": "<replace-this>", // 可以使用 xray x25519 生成
                    "shortIds": [
                        ""
                    ]
                }
            },
            "sniffing": {
                "enabled": true,
                "destOverride": [
                    "http",
                    "tls",
                    "quic"
                ]
            }
        }
    ],
    "outbounds": [
        {
            "protocol": "freedom",
            "tag": "direct"
        },
        {
            "protocol": "blackhole",
            "tag": "block"
        }
    ]
}

参考配置中的 <replace-this> 必须替换并修改为自己的配置，替换方法参考注释，其他例如 shortIds、流量过滤等可以自行决定是否配置。

参考配置支持的特性：

使用 reality 协议；
开启 vision 分流；
禁用 bittorrent、广告、回国等流量；

替换并自动更新 dat

创建更新脚本：

# 创建脚本文件夹
mkdir /usr/local/etc/xray-script
# 打开并编辑更新脚本
vim /usr/local/etc/xray-script/update-dat.sh

脚本内容：

#!/usr/bin/env bash

set -e

XRAY_DIR="/usr/local/share/xray"

GEOIP_URL="https://github.com/Loyalsoldier/v2ray-rules-dat/raw/release/geoip.dat"
GEOSITE_URL="https://github.com/Loyalsoldier/v2ray-rules-dat/raw/release/geosite.dat"

[ -d $XRAY_DIR ] || mkdir -p $XRAY_DIR
cd $XRAY_DIR

curl -L -o geoip.dat.new $GEOIP_URL
curl -L -o geosite.dat.new $GEOSITE_URL

rm -f geoip.dat geosite.dat

mv geoip.dat.new geoip.dat
mv geosite.dat.new geosite.dat

systemctl -q is-active xray && systemctl restart xray

赋予可执行权限：

chmod +x /usr/local/etc/xray-script/update-dat.sh

可以输入以下命令先手动执行一次：

/usr/local/etc/xray-script/update-dat.sh

确认没有问题后使用 crontab 设置定期执行：

执行 crontab -e；
选择使用 vim 打开；
在文件末尾追加 00 23 * * 1 /usr/local/etc/xray-script/update-dat.sh >/dev/null 2>&1

说明：可自行决定更新时间，示例中为每周一 23 点执行（注意服务器时区）。

回落域名的选择

基本要求

根据 reality 文档的说明回落域名的网站需要满足以下要求：

国外网站，网站服务器在国外且未被 GFW 屏蔽，越靠近代理服务越好（伪装效果更好，延迟也更低）；
支持 TLSv1.3 与 H2；
域名非跳转用；

另外需要注意的是，不要选择套了 Cloudflare CDN 的网站，有被其他人当作中转服务器的风险。

一般来讲回落域名选择有以下几种选择：

海外大厂的域名，例如 Microsoft、Apple 等；
代理服务器的当地网站，例如当地大学、旅游局等机构的网站；
自己网上邻居的网站；
自己的网站；

除选择 1 不推荐以外，其他选择可以自行决定使用哪种，本文以选择 3 为例。

找到网上邻居的网站

分为以下几步：

使用 ASN 查询工具查询代理服务器的 ASN；
使用 FOFA 查找符合条件的网站，查询条件为 asn=="<replace-this>" && country=="US" && port=="443" && cert!="Let's Encrypt" && cert.issuer!="ZeroSSL" && status_code="200"；
逐个验证查询到的网站是否满足回落域名的要求（使用浏览器的开发人员工具验证）；

注意：需要将 FOFA 查询条件中的 <replace-this> 替换为你代理服务器的 ASN，一定要用浏览器打开网站验证，确保能正常打开，是正规网站且满足回落域名要求。

TLS 版本可以打开开发人员工具后在 Security 选项卡中查看；是否支持 H2 可以在 Network 选项卡中查看 Protocol 列（默认未勾选）或者使用在线网站检测。

客户端配置

以 mihomo 内核配置为例：

proxies:
- name: "node1"
  type: vless
  server: <replace-this> # 代理服务器地址
  port: 443
  udp: true
  uuid: <replace-this> # Xray 服务端的 UUID
  flow: xtls-rprx-vision
  tls: true
  servername: <replace-this> # 服务端配置的可用 server name
  client-fingerprint: chrome
  skip-cert-verify: false
  reality-opts: 
    public-key: <replace-this> # 与服务端私钥配套的公钥
  network: tcp

将所有 <replace-this> 替换为自己的信息，如果服务端设置了 shortIds 可自行配置。

参考连接

Arch Linux 安装

Sat, 13 Mar 2021 09:46:00 GMT

下载镜像

在 Arch Linux - Downloads 页面任意找一个镜像站下载，国内推荐使用清华大学开源软件镜像站。

安装系统

系统刻录

推荐使用 balenaEtcher，虚拟机安装则直接选择下载后的镜像即可。

准备操作

确保已经连接到网络，直接连接有线网络或通过 iwctl 连接无线网络

# 同步系统时间
timedatectl set-ntp true

磁盘分区

使用上一步创建启动盘启动系统，启动后会进入一个命令提示符界面，接着开始对磁盘进行分区操作。

注意：此步骤分区基于 GPT 分区表

# 查看磁盘列表，确认要分区的磁盘编号
fdisk -l

# 确认编号后开始进行分区，我这里是磁盘编号为 sda（依据实际情况修改）
fdisk /dev/sda
# 接着按序号进行操作
1. p # 显示分区信息
2. g # 创建 GPT 分区表
3. p # 再次查看分区信息

4. n # 开始创建引导分区
5. <CR> # 回车，分区编号默认
6. <CR> # 回车，起始柱面默认
7. +512M # 启动分区分配 512M

8. n # 开始创建 swap 分区
9. 3 # 分区编号设置为 3
10. <CR> # 回车，起始柱面默认
11. +4G # 交换分区分配 4G（一般为内存大小的 2 倍）

12. n # 开始创建数据分区
13. <CR> # 回车，分区编号默认
14. <CR> # 回车，起始柱面默认
15. <CR> # 回车，剩余空间全部分配给数据分区

16. p # 查看分区信息
17. w # 保存分区信息

格式化分区

# 查看磁盘列表，确认要格式化的分区编号
fdisk -l

# 格式化引导分区，我这里编号为 sda1（依据实际情况修改）
mkfs.fat -F32 /dev/sda1
# 格式化数据分区
mkfs.ext4 /dev/sda2
# 设置并开启 swap 分区
mkswap /dev/sda3
swapon /dev/sda3

挂载分区

# 将数据分区挂载到 /mnt
mount /dev/sda2 /mnt
# 创建引导分区挂载点并挂载
mkdir /mnt/boot
mount /dev/sda1 /mnt/boot

开始安装

# 安装必须的软件、Linux 内核及硬件驱动
pacstrap /mnt base linux linux-firmware

# 生成 fstab
genfstab -U /mnt >> /mnt/etc/fstab
# 检查生成后的 fstab 文件
cat /mnt/etc/fstab

# 进入到新安装的系统
arch-chroot /mnt
# 配置时区（依据实际情况修改）
ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
# 同步系统时间
hwclock --systohc
# 检查时间
date
# 退回到安装引导系统
exit

# 配置编码
# 编辑文件打开这两行注释
vim /mnt/etc/locale.gen
en_US.UTF-8 UTF-8
zh_CN.UTF-8 UTF-8
# 新建文件新增一行
vim /mnt/etc/locale.conf
LANG=en_US.UTF-8

# 配置主机名（依据实际情况修改）
echo myhostname > /mnt/etc/hostname

# 重新进入到新安装的系统
arch-chroot /mnt
# 生成编码
locale-gen
# 设置 root 密码
passwd
# 安装引导
pacman -S grub efibootmgr intel-ucode os-prober
# 生成 grub 配置
mkdir /boot/grub
grub-mkconfig > /boot/grub/grub.cfg
# 确认电脑类型，我这里是 x86_64
uname -m
x86_64

# 根据上一步确认的电脑类型安装 grub
grub-install --target=x86_64-efi --efi-directory=/boot

# 安装必要及常用的软件
pacman -S vim vi zsh dhcpcd

# 退回到安装引导系统
exit
# 重启
reboot

安装后的配置

重启后拔掉启动 U 盘或删除 arch 镜像盘片（虚拟机安装）。使用 root 用户登录，密码为在上一节中自行设置的密码。

网络设置

# 确认网卡编号
ip a

# 手动联网，我这里网卡编号为 enp0s3（依据实际情况修改）
ip link set enp0s3 up
dhcpcd &

# 设置开机自动联网（依据实际情况修改网卡编号）
systemctl enable dhcpcd@enp0s3
systemctl start dhcpcd@enp0s3
systemctl status dhcpcd@enp0s3

系统更新

# 更新最新系统
pacman -Syyu
# 安装必要软件
pacman -S base-devel

新建用户

# 新建 tom（依据实际情况修改）
useradd -m -G wheel tom
# 设置 tom 的密码（依据实际情况修改）
passwd tom

# 配置权限
visudo
# 82 行左右，取消注释
%wheel ALL=(ALL) ALL

# 退出 root 登陆 tom 或其它
exit

HTTPS 安全原理

Mon, 28 Sep 2020 20:18:00 GMT

为什么要加密？

如果所有的信息都在互联网上进行明文传输，那么就意味着所有信息都可以被“黑客”随意获取或篡改。

如何加密？

对称加密

设：加密函数为 encode，解密函数为 decode，秘钥为 key，要传输的数据为 data，加密后的数据为 x_data

可得：

encode(key, data) = x_data
decode(key, x_data) = data

即：加密和解密的过程都是通过同一个秘钥 key 完成的，所以对称加密的“**对称”**指的是加密和解密用的是同一个秘钥 key。

下面模拟一次请求的过程：

客户端发送消息时：使用 encode(key, data) = x_data 得到加密后的数据 x_data 并传输给服务端；

服务端接收消息时：接收到加密后的数据 x_data 后使用 decode(key, x_data) = data 解密后得到原始数据 data。

服务器返回消息和客户端接收消息同样的道理不再赘述。

但是问题来了：如何制定秘钥 key 呢？

所有客户端都使用同一个秘钥 key。

那就和明文没有任何区别了，因为任何人（包括“黑客”）都可以通过成为客户端来获取秘钥。
每个客户端制定一个秘钥 key。

i. 首先如何安全的分发定制好的秘钥 key ？这本身也是一个安全通信的问题，一种解决方案是提前与客户端约定好密钥 key，但是这样就会带来下面的第二个问题；

ii. 如果服务端需要和 n 个客户端通信就需要维护 n 个秘钥，当 n 非常大时维护成本也会变得非常高。

所以使用对称加密无法保证整个传输过程的安全性。

非对称加密

设：加密函数为 encode，解密函数为 decode，公钥为 public_key，私钥为 private_key，要传输的数据为 data，使用公钥加密后的数据为 x_data，使用私钥加密后的数据为 x_data’

可得：

encode(public_key, data) = x_data
decode(private_key, x_data) = data
encode(private_key, data) = x_data’
decode(public_key, x_data’) = data

即：通过公钥 public_key 加密后的数据可以使用私钥 private_key 进行解密，反之通过私钥 private_key 加密的数据也可以通过公钥 public_key 进行解密。所以非对称加密的“非对称”指的是加密和解密的秘钥需要分别使用公钥 public_key，私钥 private_key。

public_key 是公开的（对于所有人都是如此），而 private_key 必须保密，只有服务端知道。

下面也模拟一次请求：

客户端发送消息时：使用 f1(public_key, data) = x_data 得到加密后的数据 x_data 并传输给服务端；
服务端接收数据时：接收到加密后的数据 x_data 后使用 f2(private_key, x_data) = data 解密后得到原始数据 data；

问题又来了：服务端返回的数据该如何加密？

使用公钥加密？

上边提到私钥只有服务端知道，客户端并没有私钥，所以无法解密数据*。*
那使用私钥加密呢？

上边提到使用私钥加密后的数据可以通过公钥进行解密，同时公钥又是对所有人公开的，那就又和明文没有任何区别了。

所以使用非对称加密也无法保证整个传输过程的安全性。

HTTPS 如何加密

既然对称加密和非对称加密都无法保证整个传输过程的安全性，那 HTTPS 是如何保证安全性的呢？

首先我们总结一下需要解决的问题：

对称加密无法保证密钥分发的安全性；
非对称加密无法保证服务端返回数据的安全性；
非对称加密的计算量相对于对称加密来说非常巨大，所以如果整个通信过程中都使用非对称加密那么加解密的过程就会消耗大量的服务器资源。

下面我们将结合对称加密和非对称加密模拟请求的过程：

客户端向服务端请求公钥；
服务端返回公钥；
客户端生成随机数 num 并使用公钥加密后发送给服务端；
服务端接收到请求后使用私钥解密得到随机数 num ；
接下来使用的通信都使用对称加密并将 num 作为加密的密钥。

中间人攻击

如果在客户端和服务器之间通信的一开始就存在一个中间人张三，他首先拦截客户端请求，再将自己伪装成客户端向服务端发起请求；当服务端返回数据时，张三也首先拦截到返回数据，再伪装为服务端将数据返回给客户端。

CA 机构

之所以可以进行中间人攻击是因为客户端无法校验公钥的正确性，比如当客户端请求到公钥后如何证明此公钥就是原本预想的那台服务器发行的公钥，而不是被张三所替换后的公钥，为了解决这个问题我们就需要引入 CA 机构加入到通信过程中。

问题：

ca_public_key 是如何分发到客户端的？一旦通过网络传输不还是会存在中间人问题？

所以 ca_public_key 不通过网络分发，而是直接安装在操作系统中，随操作系统或浏览器分发。

HTTPS 对话密钥协商过程（简化版本）

客户端向服务器发起 Client Hello 请求

i. 客户端支持的 TLS 版本号

ii. 随机数 num1

iii. 客户端支持的加密算法
服务端收到请求，响应 Server Hello

i. 确认要使用的 TLS 版本号

ii. 随机数 num2

iii. 确认要使用的加密算法

iiii. 服务器证书 license
客户端接收服务端响应，校验 license 有效性
客户端继续发起请求

i. 随机数 num3，使用服务器公钥加密

ii. num1、num2 摘要信息，hash(num1, num2)
服务端收到请求，校验摘要信息，同时使用 num1、num2、num3 生成对话密钥
服务端返回数据

i. hash(num1、num2、num3)
客户端接收请求并校验摘要信息，同时使用 num1、num2、num3 生成对话密钥

注意

协商过程是明文进行的
对话密钥不在网络上进行传输，而是由服务端和客户端各自计算出来的

（完）

使用 Certbot 自动申请并续订阿里云 DNS 免费泛域名证书

Wed, 29 Apr 2020 11:17:00 GMT

背景

Certbot 支持自动申请 LetsEncrypt 的泛域名证书，但是官方插件不支持阿里云，在 GitHub 搜索发现已经有人写好了阿里云 DNS 插件，下面只需要进行简单的配置即可免费申请一个泛域名证书并自动续订。

操作步骤

安装 Certbot 和 certbot-dns-aliyun

本文基于 CentOS 7

首先安装 Python 3
```
yum install -y python36
```

创建并激活虚拟环境

mkdir -p /mnt/certbot
cd /mnt/certbot
python3 -m venv venv
source venv/bin/activate

安装 Certbot 和 certbot-dns-aliyun

pip install certbot certbot-nginx certbot-dns-aliyun

申请并配置阿里云 DNS 访问密钥

前往 https://ram.console.aliyun.com 申请阿里云子账号并授予 AliyunDNSFullAccess 权限。然后为子账号创建 AccessKey 并记录。

创建 certbot-dns-aliyun 配置文件：

cat > /mnt/certbot/credentials.ini <<EOF
certbot_dns_aliyun:dns_aliyun_access_key = 12345678
certbot_dns_aliyun:dns_aliyun_access_key_secret = 1234567890abcdef1234567890abcdef
EOF

修改文件权限

chmod 600 /mnt/certbot/credentials.ini

申请证书

/mnt/certbot/venv/bin/certbot certonly \
-a certbot-dns-aliyun:dns-aliyun \
--certbot-dns-aliyun:dns-aliyun-credentials /mnt/certbot/credentials.ini \
-d yourdomain.com \
-d "*.yourdomain.com"

配置自动续订：

echo "0 0,12 * * * root python -c 'import random; import time; time.sleep(random.random() * 3600)' && /mnt/certbot/venv/bin/certbot renew -q" | sudo tee -a /etc/crontab > /dev/null

配置 nginx

cat > /etc/nginx/conf.d/nginx.header <<EOF
listen 80;
listen 443 ssl;
if ($scheme != https) {
    rewrite ^/(.*) https://$server_name/$1 permanent;
} 
ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem;
include /etc/letsencrypt/options-ssl-nginx.conf;
ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
EOF

cat > /etc/nginx/conf.d/yourdomain.com.conf <<EOF
server {
    server_name  yourdomain.com;
    include      /etc/nginx/conf.d/nginx.header;

    location / {
        proxy_set_header  Host $host;  
        proxy_set_header  X-Real-IP $remote_addr;  
        proxy_set_header  X-Forwarded-For $proxy_add_x_forwarded_for;  
        proxy_set_header  X-Forwarded-Proto $scheme;  

        proxy_pass http://127.0.0.1:8080;
    }
}
EOF

解决 Elasticsearch 查询时 Fielddata is disabled on text fields by default 错误

Tue, 28 Apr 2020 11:17:00 GMT

问题描述

以下过程基于 Elasticsearch 7.3

Elasticsearch 启动后无法查询，检查日志发现这样一行日志：

Caused by: java.lang.IllegalArgumentException: Fielddata is disabled on text fields by default. Set fielddata=true on [type] in order to load fielddata in memory by uninverting the inverted index. Note that this can however use significant memory. Alternatively use a keyword field instead.

日志其实已经说得很清楚了，默认情况下 text 类型的字段 fielddata 被禁用。官方文档在这里。

继续排查日志发现：

Failed to execute [SearchRequest{searchType=QUERY_THEN_FETCH, indices=[.kibana], indicesOptions=IndicesOptions......

是启动 kibana 时报的错。

解决方案

根据文档说明将 [type] 字段 fielddata 设置为 true：

curl -X PUT "localhost:9200/.kibana/_mapping?pretty" -H 'Content-Type: application/json' -d'
{
  "properties": {
    "type": {
      "type":     "text",
      "fielddata": true
    }
  }
}
'

总结

首先找到是哪个索引下的哪个字段报错，此例中就是 .kibana 索引的 type 字段，然后将对应字段 fielddata 设置为 true 解决问题。

修改配置：

curl -X PUT "localhost:9200/[modify_this_index]/_mapping?pretty" -H 'Content-Type: application/json' -d'
{
  "properties": {
    "[modify_this_field]": {
      "type":     "text",
      "fielddata": true
    }
  }
}
'

验证结果：

curl -X GET "localhost:9200/[modify_this_index]/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "aggs": {
    "all_[modify_this_field]": {
      "terms": { "field": "[modify_this_field]" }
    }
  }
}
'

将 [modify_this_index] 和 [modify_this_field] 修改为对应的索引和字段即可。

Android Pie（Android 9）跳过 Google 框架 (GApps) 开机验证方法

Sat, 02 Mar 2019 17:03:00 GMT

如果刷机时刷入了 Google 框架（GApps）可以使用以下方法跳过验证：

进入TWRP，并 mount system 分区，数据线链接电脑。

打开 cmd 或其它终端：

# 将 build.prop 拉取到当前目录
$ adb pull system/build.prop .

# 使用记事本或其他软件在 build.prop 文件最后加入以下代码
ro.setupwizard.mode=DISABLED

# 将 build.prop 文件放回 system
$ adb push ./build.prop system

# 进入手机内部 shell
$ adb shell

# 修改 build.prop 文件权限 (拷贝命令可能有问题，建议直接输入)
$ chmod 0644 system/build.prop

# 退出手机 shell
$ exit

最后拔下数据线重启手机就会跳过验证直接进入桌面了

（完）

Jenkins kubernetes-plugin 使用 Gradle 构建时 Permission denied 问题

Mon, 20 Aug 2018 18:10:00 GMT

在使用 Jenkins 的 kubernetes-plugin 插件时发现使用 Gradle 镜像构建项目时出现 Permission denied 错误，具体错误如下：

[test] Running shell script
sh: 1: cannot create /home/jenkins/workspace/test@tmp/durable-b7fece0a/jenkins-log.txt: Permission denied
sh: 1: cannot create /home/jenkins/workspace/test@tmp/durable-b7fece0a/jenkins-result.txt.tmp: Permission denied
sh: 1: ps: not found
mv: cannot stat '/home/jenkins/workspace/test@tmp/durable-b7fece0a/jenkins-result.txt.tmp': No such file or directory

问题排查

既然出现 Permission denied 肯定要从权限入手了，看错误信息是在工作目录发生的错误，因为 kubernetes-plugin 这个插件会将工作目录挂载出去，以保证所有容器都能访问，所以可能就是就是各个容器的权限不统一造成的，下边验证下这个猜想。

验证

我的 Jenkinsfile 如下：

#!/usr/bin/env groovy
pipeline {
  agent {
    kubernetes {
        label "mypod-${UUID.randomUUID().toString()}"
        yaml """
apiVersion: v1
kind: Pod
metadata:
  name: jenkins-agents
spec:
  containers:
  - name: gradle
    image: gradle:4.9-jdk8-alpine
    command:
    - cat
    tty: true
    volumeMounts:
    - mountPath: /home/gradle/.gradle/caches
      name: gradle-caches
      readOnly: false
  volumes:
  - name: gradle-caches
    persistentVolumeClaim:
      claimName: gradle-caches
"""
    }
  }
    stages {
        stage('编译测试') {
            stages {
                stage('拉取代码') {
                    steps {
                        git credentialsId: 'gitlab-jenkins', url: 'xxxxxxxx'
                    }
                }
                stage('Gradle 编译打包') {
                    steps {
                        container('gradle') {
                            sh 'gradle build'
                        }
                    }
                }
            }
        }
    }
}

一共只用到两个容器：除了默认的 jnlp 就只有 gradle 了，所用镜像分别是 jenkins/jnlp-slave:3.10-1 和 gradle:4.9-jdk8-alpine。

首先查看下两个镜像默认用户的信息：

$ docker run --rm jenkins/jnlp-slave:3.10-1 id
uid=10000(jenkins) gid=10000(jenkins) groups=10000(jenkins)

$ docker run --rm gradle:4.9-jdk8-alpine id
uid=1000(gradle) gid=1000(gradle) groups=1000(gradle)

可以看到 jnpl 的 jenkins 用的 uid 和 gid 居然是 10000，而 gradle 的 gradle 用户的 uid 和 gid 为 1000。

为了弄清楚到底怎么回事，找到 Dockerfile 一探究竟，首先找到 jenkins/jnlp-slave

[jenkins/jnlp-slave]

FROM jenkins/slave:3.23-1
MAINTAINER Oleg Nenashev <o.v.nenashev@gmail.com>
LABEL Description="This is a base image, which allows connecting Jenkins agents via JNLP protocols" Vendor="Jenkins project" Version="3.23"

COPY jenkins-slave /usr/local/bin/jenkins-slave

ENTRYPOINT ["jenkins-slave"]

只是个空壳，找到 jenkins/slave

FROM openjdk:8-jdk
MAINTAINER Oleg Nenashev <o.v.nenashev@gmail.com>

ARG user=jenkins
ARG group=jenkins
ARG uid=10000
ARG gid=10000

ENV HOME /home/${user}
RUN groupadd -g ${gid} ${group}
RUN useradd -c "Jenkins user" -d $HOME -u ${uid} -g ${gid} -m ${user}
LABEL Description="This is a base image, which provides the Jenkins agent executable (slave.jar)" Vendor="Jenkins project" Version="3.23"

ARG VERSION=3.23
ARG AGENT_WORKDIR=/home/${user}/agent

RUN curl --create-dirs -sSLo /usr/share/jenkins/slave.jar https://repo.jenkins-ci.org/public/org/jenkins-ci/main/remoting/${VERSION}/remoting-${VERSION}.jar \
  && chmod 755 /usr/share/jenkins \
  && chmod 644 /usr/share/jenkins/slave.jar

USER ${user}
ENV AGENT_WORKDIR=${AGENT_WORKDIR}
RUN mkdir /home/${user}/.jenkins && mkdir -p ${AGENT_WORKDIR}

VOLUME /home/${user}/.jenkins
VOLUME ${AGENT_WORKDIR}
WORKDIR /home/${user}

可以看到 Dockerfile 里指定的 uid 和 gid 确实是 10000，至于为什么是 10000 没有提到。

解决方案

既然已经找到了问题所在，那么只要把 gradle 镜像的 uid 和 gid 也改为 10000 应该就可以了，下面就试一下。

首先找到 gradle 的原始 Dockerfile 并修改如下：

FROM openjdk:8-jdk-alpine

CMD ["gradle"]

ENV GRADLE_HOME /opt/gradle
ENV GRADLE_VERSION 4.9

ARG GRADLE_DOWNLOAD_SHA256=e66e69dce8173dd2004b39ba93586a184628bc6c28461bc771d6835f7f9b0d28
RUN set -o errexit -o nounset \
	&& echo "Installing build dependencies" \
	&& apk add --no-cache --virtual .build-deps \
		ca-certificates \
		openssl \
		unzip \
	\
	&& echo "Downloading Gradle" \
	&& wget -O gradle.zip "https://services.gradle.org/distributions/gradle-${GRADLE_VERSION}-bin.zip" \
	\
	&& echo "Checking download hash" \
	&& echo "${GRADLE_DOWNLOAD_SHA256} *gradle.zip" | sha256sum -c - \
	\
	&& echo "Installing Gradle" \
	&& unzip gradle.zip \
	&& rm gradle.zip \
	&& mkdir /opt \
	&& mv "gradle-${GRADLE_VERSION}" "${GRADLE_HOME}/" \
	&& ln -s "${GRADLE_HOME}/bin/gradle" /usr/bin/gradle \
	\
	&& apk del .build-deps \
	\
	&& echo "Adding gradle user and group" \
	&& addgroup -S -g 10000 gradle \
	&& adduser -D -S -G gradle -u 10000 -s /bin/ash gradle \
	&& mkdir /home/gradle/.gradle \
	&& chown -R gradle:gradle /home/gradle \
	\
	&& echo "Symlinking root Gradle cache to gradle Gradle cache" \
	&& ln -s /home/gradle/.gradle /root/.gradle

# Create Gradle volume
USER gradle
VOLUME "/home/gradle/.gradle"
WORKDIR /home/gradle

RUN set -o errexit -o nounset \
	&& echo "Testing Gradle installation" \
	&& gradle --version

只是把 uid 和 gid 由 1000 改为 10000

结果

镜像构建完成后使用新镜像重新 build 项目，问题解决！

虚拟机部署 Kubernetes v1.10.3 高可用集群 - 05 总结

Wed, 30 May 2018 17:47:00 GMT

本文的大部分思路参考了『Kubernetes v1.10.x HA 全手動苦工安裝教學(TL;DR)』这篇文章。

不过，虽然 Kairen 同志已经写得很详细了，但是实践起来还是有不少问题的，我在他的基础上根据自己的实践过程写了这篇文档。

可能会出现的问题

apiserver 会一直报错：
```
x509.go:172] x509: subject with cn=system:kube-controller-manager is not in the allowed list: [aggregator]
```
一开始以为是证书有问题，但是查了很久也没发现问题所在，可以忽略此错误，暂时未发现对集群有什么影响。
pod 无法启动，出现 Permission denied 之类的错误。

是由于主机未关闭 SELinux 造成的，参考『虚拟机部署 Kubernetes v1.10.3 高可用集群 - 01 虚拟机环境准备』中的步骤关闭 SELinux 即可。
无法下载镜像问题（墙）。

可以使用 shadowsocks + Proxifier 代理解决；或者使用阿里云仓库里的镜像，脚本如下：

$ ALI_REP="registry.cn-hangzhou.aliyuncs.com/google_containers"
$ GCR="gcr.io/google_containers"
$ K8S_GCR="k8s.gcr.io"

$ for IMAGE in kube-controller-manager-amd64:v1.10.3 kube-apiserver-amd64:v1.10.3 kube-scheduler-amd64:v1.10.3 etcd-amd64:3.1.13; do
    echo "--- $IMAGE ---"
    docker pull $ALI_REP/$IMAGE
    docker tag $ALI_REP/$IMAGE $GCR/$IMAGE
    docker rmi $ALI_REP/$IMAGE
done

$ for IMAGE in kube-proxy-amd64:v1.10.3 pause-amd64:3.1; do
    echo "--- $IMAGE ---"
    docker pull $ALI_REP/$IMAGE
    docker tag $ALI_REP/$IMAGE $K8S_GCR/$IMAGE
    docker rmi $ALI_REP/$IMAGE
done

虚拟机部署 Kubernetes v1.10.3 高可用集群 - 04 部署 Node

Wed, 30 May 2018 17:45:00 GMT

在开始部署前，先在 kube-m1 将需要用到的文件复制到所有 node 节点上：

$ cd /etc/kubernetes/ssl

$ for NODE in kube-n1 kube-n2 kube-n3; do
    echo "--- $NODE ---"
    ssh ${NODE} "mkdir -p /etc/kubernetes/ssl/"
    ssh ${NODE} "mkdir -p /etc/etcd/ssl"
    # Etcd
    for FILE in etcd.pem etcd-key.pem; do
      scp /etc/etcd/ssl/${FILE} ${NODE}:/etc/etcd/ssl/${FILE}
    done
    # Kubernetes
    for FILE in ssl/ca.pem ssl/ca-key.pem bootstrap-kubelet.conf; do
      scp /etc/kubernetes/${FILE} ${NODE}:/etc/kubernetes/${FILE}
    done
done

部署与设定

以下所有操作需要在每台 Node 节点上都进行一遍。

在每台 node 节点配置 kubelet.service 相关文件来管理 kubelet：

安装 cni 网络插件：

$ mkdir -p /opt/cni/bin && cd /opt/cni/bin
$ export CNI_URL="https://github.com/containernetworking/plugins/releases/download"
$ wget -qO- "${CNI_URL}/v0.6.0/cni-plugins-amd64-v0.6.0.tgz" | tar -zx

配置 kubelet.service：

$ cat > /usr/lib/systemd/system/kubelet.service <<EOF
[Unit]
Description=Kubernetes Kubelet
Documentation=https://github.com/GoogleCloudPlatform/kubernetes
After=docker.service
Requires=docker.service

[Service]
Environment="KUBELET_KUBECONFIG_ARGS=--bootstrap-kubeconfig=/etc/kubernetes/bootstrap-kubelet.conf --kubeconfig=/etc/kubernetes/kubelet.conf"
Environment="KUBELET_SYSTEM_PODS_ARGS=--pod-manifest-path=/etc/kubernetes/manifests --allow-privileged=true"
Environment="KUBELET_NETWORK_ARGS=--network-plugin=cni --cni-conf-dir=/etc/cni/net.d --cni-bin-dir=/opt/cni/bin"
Environment="KUBELET_DNS_ARGS=--cluster-dns=10.254.0.2 --cluster-domain=cluster.local"
Environment="KUBELET_AUTHZ_ARGS=--authorization-mode=Webhook --client-ca-file=/etc/kubernetes/ssl/ca.pem"
Environment="KUBELET_CADVISOR_ARGS=--cadvisor-port=0"
Environment="KUBELET_CERTIFICATE_ARGS=--rotate-certificates=true --cert-dir=/var/lib/kubelet/ssl"
Environment="KUBELET_EXTRA_ARGS=--node-labels=node-role.kubernetes.io/node='' --logtostderr=true --v=0 --fail-swap-on=false --cgroup-driver=systemd"
ExecStart=/usr/local/bin//kubelet \$KUBELET_KUBECONFIG_ARGS \$KUBELET_SYSTEM_PODS_ARGS \$KUBELET_NETWORK_ARGS \$KUBELET_DNS_ARGS \$KUBELET_AUTHZ_ARGS \$KUBELET_CADVISOR_ARGS \$KUBELET_CERTIFICATE_ARGS \$KUBELET_EXTRA_ARGS
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target
EOF

最后建立 var 存放信息，然后启动 kubelet 服务:

$ mkdir -p /var/lib/kubelet /var/log/kubernetes

$ systemctl enable kubelet.service && systemctl start kubelet.service

验证集群

在任意 Mater 执行以下命令：

$ kubectl get csr
csr-xtvv5                                              1h        system:node:kube-m1       Approved,Issued
csr-bm696                                              1h        system:node:kube-m2       Approved,Issued
csr-s95db                                              1h        system:node:kube-m3       Approved,Issued
node-csr-7EpNHKBXNxc75nKEbT10qweZ5tPNSVYSW9lHhgXP_io   5m        system:bootstrap:c63cdb   Approved,Issued
node-csr-MLS26OAthEDtOVKcu9UYoA6sldkUEj49MTv278z-w7o   1m        system:bootstrap:c63cdb   Approved,Issued
node-csr-rJUWN98SoxqdtTcfToALKB7Whj55wl4WPGcGxLQBIHo   1m        system:bootstrap:c63cdb   Approved,Issued

$ kubectl get nodes
kube-m1   NotReady   master    1h        v1.10.3
kube-m2   NotReady   master    1h        v1.10.3
kube-m3   NotReady   master    1h        v1.10.3
kube-n1   NotReady   node      7m        v1.10.3
kube-n2   NotReady   node      2m        v1.10.3
kube-n3   NotReady   node      2m        v1.10.3

Kubernetes Core Addons 部署

当完成上面所有步骤后，接着需要部署一些插件，如 Kubernetes DNS 与 Kubernetes Proxy 等。

Kubernetes Proxy

Kube-proxy 是实现 Service 的关键插件，kube-proxy 会在每台节点上执行，然后监听 API Server 的 Service 与 Endpoint 资源物件的改变，然后来依据变化执行 iptables 来实现网络的转发。这边我们会需要建议一个 DaemonSet 来执行，并且建立一些需要的 Certificates。

在 kube-m1 配置 kube-proxy.yml 来安装 Kubernetes Proxy 插件：

$ mkdir /etc/kubernetes/addon && cd /etc/kubernetes/addon
$ cat > /etc/kubernetes/addon/kube-proxy.yml <<EOF
apiVersion: v1
kind: ServiceAccount
metadata:
  name: kube-proxy
  namespace: kube-system
  labels:
    addonmanager.kubernetes.io/mode: Reconcile
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: system:kube-proxy
  labels:
    addonmanager.kubernetes.io/mode: Reconcile
subjects:
  - kind: ServiceAccount
    name: kube-proxy
    namespace: kube-system
roleRef:
  kind: ClusterRole
  name: system:node-proxier
  apiGroup: rbac.authorization.k8s.io
---
apiVersion: v1
kind: ConfigMap
metadata:
  labels:
    app: kube-proxy
  name: kube-proxy
  namespace: kube-system
data:
  config.conf: |-
    apiVersion: kubeproxy.config.k8s.io/v1alpha1
    bindAddress: 0.0.0.0
    clientConnection:
      acceptContentTypes: ""
      burst: 10
      contentType: application/vnd.kubernetes.protobuf
      kubeconfig: /var/lib/kube-proxy/kubeconfig.conf
      qps: 5
    clusterCIDR: 172.30.0.0/16
    configSyncPeriod: 15m0s
    conntrack:
      max: null
      maxPerCore: 32768
      min: 131072
      tcpCloseWaitTimeout: 1h0m0s
      tcpEstablishedTimeout: 24h0m0s
    enableProfiling: false
    healthzBindAddress: 0.0.0.0:10256
    hostnameOverride: ""
    iptables:
      masqueradeAll: false
      masqueradeBit: 14
      minSyncPeriod: 0s
      syncPeriod: 30s
    ipvs:
      minSyncPeriod: 0s
      scheduler: ""
      syncPeriod: 30s
    kind: KubeProxyConfiguration
    metricsBindAddress: 127.0.0.1:10249
    mode: ""
    nodePortAddresses: null
    oomScoreAdj: -999
    portRange: ""
    resourceContainer: /kube-proxy
    udpIdleTimeout: 250ms
  kubeconfig.conf: |-
    apiVersion: v1
    kind: Config
    clusters:
    - cluster:
        certificate-authority: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
        server: https://192.168.56.10:6443
      name: default
    contexts:
    - context:
        cluster: default
        namespace: default
        user: default
      name: default
    current-context: default
    users:
    - name: default
      user:
        tokenFile: /var/run/secrets/kubernetes.io/serviceaccount/token
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  labels:
    k8s-app: kube-proxy
  name: kube-proxy
  namespace: kube-system
spec:
  selector:
    matchLabels:
      k8s-app: kube-proxy
  template:
    metadata:
      labels:
        k8s-app: kube-proxy
    spec:
      tolerations:
      - effect: NoSchedule
        key: node-role.kubernetes.io/master
      - effect: NoSchedule
        key: node.cloudprovider.kubernetes.io/uninitialized
        value: "true"
      hostNetwork: true
      restartPolicy: Always
      serviceAccount: kube-proxy
      serviceAccountName: kube-proxy
      containers:
      - name: kube-proxy
        image: k8s.gcr.io/kube-proxy-amd64:v1.10.3
        command:
        - /usr/local/bin/kube-proxy
        - --config=/var/lib/kube-proxy/config.conf
        imagePullPolicy: IfNotPresent
        securityContext:
          privileged: true
        volumeMounts:
        - mountPath: /var/lib/kube-proxy
          name: kube-proxy
        - mountPath: /run/xtables.lock
          name: xtables-lock
        - mountPath: /lib/modules
          name: lib-modules
          readOnly: true
      volumes:
      - configMap:
          defaultMode: 420
          name: kube-proxy
        name: kube-proxy
      - hostPath:
          path: /run/xtables.lock
          type: FileOrCreate
        name: xtables-lock
      - hostPath:
          path: /lib/modules
        name: lib-modules
EOF

安装插件：

$ kubectl create -f /etc/kubernetes/addon/kube-proxy.yml
serviceaccount "kube-proxy" created
clusterrolebinding.rbac.authorization.k8s.io "system:kube-proxy" created
configmap "kube-proxy" created
daemonset.apps "kube-proxy" created

$ kubectl -n kube-system get po -o wide -l k8s-app=kube-proxy
kube-proxy-42f4m   1/1       Running   0          47s       192.168.56.15   kube-n2
kube-proxy-5zn95   1/1       Running   0          48s       192.168.56.14   kube-n1
kube-proxy-7mwrf   1/1       Running   0          48s       192.168.56.11   kube-m1
kube-proxy-bs5p2   1/1       Running   0          47s       192.168.56.16   kube-n3
kube-proxy-qzsrx   1/1       Running   0          47s       192.168.56.13   kube-m3
kube-proxy-sgxvh   1/1       Running   0          47s       192.168.56.12   kube-m2

Kubernetes DNS

Kubernetes DNS 是 Kubernetes 集群内部 Pod 之间互相沟通的重要插件，它允许 Pod 可以通过 Domain Name 方式来连接 Service，其主要由 Kube DNS 与 Sky DNS 组合而成，通过 Kube DNS 监听 Service 与 Endpoint 变化，来提供给 Sky DNS 信息，已更新解析位址。

在 kube-m1 配置 kube-dns.yml 来安装 Kubernetes DNS 插件：

$ cd /etc/kubernetes/addon
$ cat > /etc/kubernetes/addon/kube-dns.yml <<EOF
apiVersion: v1
kind: ServiceAccount
metadata:
  name: kube-dns
  labels:
    k8s-app: kube-dns
    kubernetes.io/cluster-service: "true"
    addonmanager.kubernetes.io/mode: Reconcile
  namespace: kube-system
---
apiVersion: v1
kind: Service
metadata:
  name: kube-dns
  namespace: kube-system
  labels:
    k8s-app: kube-dns
    kubernetes.io/cluster-service: "true"
    addonmanager.kubernetes.io/mode: Reconcile
spec:
  selector:
    k8s-app: kube-dns
  clusterIP: 10.254.0.2
  ports:
  - name: dns
    port: 53
    protocol: UDP
  - name: dns-tcp
    port: 53
    protocol: TCP
---
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: kube-dns
  namespace: kube-system
  labels:
    k8s-app: kube-dns
    kubernetes.io/cluster-service: "true"
    addonmanager.kubernetes.io/mode: Reconcile
spec:
  selector:
    matchLabels:
      k8s-app: kube-dns
  template:
    metadata:
      labels:
        k8s-app: kube-dns
      annotations:
        scheduler.alpha.kubernetes.io/critical-pod: ''
    spec:
      dnsPolicy: Default
      serviceAccountName: kube-dns
      tolerations:
      - key: "CriticalAddonsOnly"
        operator: "Exists"
      - key: node-role.kubernetes.io/master
        effect: NoSchedule
      volumes:
      - name: kube-dns-config
        configMap:
          name: kube-dns
          optional: true
      containers:
      - name: kubedns
        image: gcr.io/google_containers/k8s-dns-kube-dns-amd64:1.14.7
        resources:
          limits:
            memory: 170Mi
          requests:
            cpu: 100m
            memory: 70Mi
        livenessProbe:
          httpGet:
            path: /healthcheck/kubedns
            port: 10054
            scheme: HTTP
          initialDelaySeconds: 60
          timeoutSeconds: 5
          successThreshold: 1
          failureThreshold: 5
        readinessProbe:
          httpGet:
            path: /readiness
            port: 8081
            scheme: HTTP
          initialDelaySeconds: 3
          timeoutSeconds: 5
        args:
        - "--domain=cluster.local"
        - --dns-port=10053
        - --v=2
        env:
        - name: PROMETHEUS_PORT
          value: "10055"
        ports:
        - containerPort: 10053
          name: dns-local
          protocol: UDP
        - containerPort: 10053
          name: dns-tcp-local
          protocol: TCP
        - containerPort: 10055
          name: metrics
          protocol: TCP
        volumeMounts:
        - name: kube-dns-config
          mountPath: /kube-dns-config
      - name: dnsmasq
        image: gcr.io/google_containers/k8s-dns-dnsmasq-nanny-amd64:1.14.7
        livenessProbe:
          httpGet:
            path: /healthcheck/dnsmasq
            port: 10054
            scheme: HTTP
          initialDelaySeconds: 60
          timeoutSeconds: 5
          successThreshold: 1
          failureThreshold: 5
        args:
        - "-v=2"
        - "-logtostderr"
        - "-configDir=/etc/k8s/dns/dnsmasq-nanny"
        - "-restartDnsmasq=true"
        - "--"
        - "-k"
        - "--cache-size=1000"
        - "--log-facility=-"
        - "--server=/cluster.local/127.0.0.1#10053"
        - "--server=/in-addr.arpa/127.0.0.1#10053"
        - "--server=/ip6.arpa/127.0.0.1#10053"
        ports:
        - containerPort: 53
          name: dns
          protocol: UDP
        - containerPort: 53
          name: dns-tcp
          protocol: TCP
        resources:
          requests:
            cpu: 150m
            memory: 20Mi
        volumeMounts:
        - name: kube-dns-config
          mountPath: /etc/k8s/dns/dnsmasq-nanny
      - name: sidecar
        image: gcr.io/google_containers/k8s-dns-sidecar-amd64:1.14.7
        livenessProbe:
          httpGet:
            path: /metrics
            port: 10054
            scheme: HTTP
          initialDelaySeconds: 60
          timeoutSeconds: 5
          successThreshold: 1
          failureThreshold: 5
        args:
        - "--v=2"
        - "--logtostderr"
        - "--probe=kubedns,127.0.0.1:10053,kubernetes.default.svc.cluster.local,5,A"
        - "--probe=dnsmasq,127.0.0.1:53,kubernetes.default.svc.cluster.local,5,A"
        ports:
        - containerPort: 10054
          name: metrics
          protocol: TCP
        resources:
          requests:
            memory: 20Mi
            cpu: 10m
EOF

其中 10.254.0.2 为 kubelet.service 中配置的 --cluster-dns。

安装插件：

$ kubectl create -f /etc/kubernetes/addon/kube-dns.yml
serviceaccount "kube-dns" created
service "kube-dns" created
deployment.extensions "kube-dns" created

$ kubectl -n kube-system get po -l k8s-app=kube-dns
NAME                        READY     STATUS    RESTARTS   AGE
kube-dns-654684d656-vzkjk   0/3       Pending   0          19s

这边会发现处于 Pending 状态，这是由于 Kubernetes Pod Network 还未建立完成，因此所有节点会处于 NotReady 状态，而造成 Pod 无法被排程分配到指定节点上启动，下面安装 Pod Network。

Calico Network 安装与设定

Calico 是一款纯 Layer 3 的资料中心网络方案(不需要 Overlay 网络)，Calico 好处是它整合了各种云原生平台，且 Calico 在每一个节点利用 Linux Kernel 实现高效的 vRouter 来负责资料的转发，而当资料中心复杂度增加时，可以用 BGP route reflector 来达成。

本次不采用手动方式来建立 Calico 网络，若想了解可以参考 Integration Guide。

在 kube-m1 配置 calico.yaml 来安装 Calico Network：

$ mkdir /etc/kubernetes/network && cd /etc/kubernetes/network
$ cat > /etc/kubernetes/network/calico.yml <<EOF
kind: ConfigMap
apiVersion: v1
metadata:
  name: calico-config
  namespace: kube-system
data:
  etcd_endpoints: "https://192.168.56.11:2379,https://192.168.56.12:2379,https://192.168.56.13:2379"
  calico_backend: "bird"
  cni_network_config: |-
    {
      "name": "k8s-pod-network",
      "cniVersion": "0.3.0",
      "plugins": [
        {
          "type": "calico",
          "etcd_endpoints": "__ETCD_ENDPOINTS__",
          "etcd_ca_cert_file": "/etc/kubernetes/ssl/ca.pem",
          "etcd_cert_file": "/etc/etcd/ssl/etcd.pem",
          "etcd_key_file": "/etc/etcd/ssl/etcd-key.pem",
          "log_level": "info",
          "mtu": 1500,
          "ipam": {
              "type": "calico-ipam"
          },
          "policy": {
              "type": "k8s",
               "k8s_api_root": "https://__KUBERNETES_SERVICE_HOST__:__KUBERNETES_SERVICE_PORT__",
               "k8s_auth_token": "__SERVICEACCOUNT_TOKEN__"
          },
          "kubernetes": {
              "kubeconfig": "/etc/cni/net.d/__KUBECONFIG_FILENAME__"
          }
        },
        {
          "type": "portmap",
          "snat": true,
          "capabilities": {"portMappings": true}
        }
      ]
    }
---
kind: DaemonSet
apiVersion: extensions/v1beta1
metadata:
  name: calico-node
  namespace: kube-system
  labels:
    k8s-app: calico-node
spec:
  selector:
    matchLabels:
      k8s-app: calico-node
  updateStrategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1
  template:
    metadata:
      labels:
        k8s-app: calico-node
      annotations:
        scheduler.alpha.kubernetes.io/critical-pod: ''
    spec:
      hostNetwork: true
      tolerations:
      - key: node.cloudprovider.kubernetes.io/uninitialized
        value: "true"
        effect: NoSchedule
      - key: node-role.kubernetes.io/master
        effect: NoSchedule
      - key: CriticalAddonsOnly
        operator: Exists
      serviceAccountName: calico-cni-plugin
      terminationGracePeriodSeconds: 0
      containers:
        - name: calico-node
          image: quay.io/calico/node:v3.0.4
          env:
            - name: CLUSTER_TYPE
              value: "k8s,bgp"
            - name: ETCD_ENDPOINTS
              valueFrom:
                configMapKeyRef:
                  name: calico-config
                  key: etcd_endpoints
            - name: CALICO_NETWORKING_BACKEND
              valueFrom:
                configMapKeyRef:
                  name: calico-config
                  key: calico_backend
            - name: CALICO_DISABLE_FILE_LOGGING
              value: "true"
            - name: CALICO_K8S_NODE_REF
              valueFrom:
                fieldRef:
                  fieldPath: spec.nodeName
            - name: FELIX_DEFAULTENDPOINTTOHOSTACTION
              value: "ACCEPT"
            - name: CALICO_IPV4POOL_CIDR
              value: "10.244.0.0/16"
            - name: CALICO_IPV4POOL_IPIP
              value: "Always"
            - name: FELIX_IPV6SUPPORT
              value: "false"
            - name: FELIX_IPINIPMTU
              value: "1440"
            - name: FELIX_LOGSEVERITYSCREEN
              value: "info"
            - name: IP
              value: "autodetect"
            - name: FELIX_HEALTHENABLED
              value: "true"
            - name: IP_AUTODETECTION_METHOD
              value: "interface=eth1"
            - name: IP6_AUTODETECTION_METHOD
              value: "interface=eth1"
            - name: ETCD_CA_CERT_FILE
              value: "/etc/kubernetes/ssl/ca.pem"
            - name: ETCD_CERT_FILE
              value: "/etc/etcd/ssl/etcd.pem"
            - name: ETCD_KEY_FILE
              value: "/etc/etcd/ssl/etcd-key.pem"
          securityContext:
            privileged: true
          resources:
            requests:
              cpu: 250m
          livenessProbe:
            httpGet:
              path: /liveness
              port: 9099
            periodSeconds: 10
            initialDelaySeconds: 10
            failureThreshold: 6
          readinessProbe:
            httpGet:
              path: /readiness
              port: 9099
            periodSeconds: 10
          volumeMounts:
            - mountPath: /lib/modules
              name: lib-modules
              readOnly: true
            - mountPath: /var/run/calico
              name: var-run-calico
              readOnly: false
            - mountPath: /etc/etcd/ssl
              name: etcd-ca-certs
            - mountPath: /etc/kubernetes/ssl
              name: kubernetes-ca-certs
              readOnly: true
        - name: install-cni
          image: quay.io/calico/cni:v2.0.3
          command: ["/install-cni.sh"]
          env:
            - name: CNI_CONF_NAME
              value: "10-calico.conflist"
            - name: ETCD_ENDPOINTS
              valueFrom:
                configMapKeyRef:
                  name: calico-config
                  key: etcd_endpoints
            - name: CNI_NETWORK_CONFIG
              valueFrom:
                configMapKeyRef:
                  name: calico-config
                  key: cni_network_config
          volumeMounts:
            - mountPath: /host/opt/cni/bin
              name: cni-bin-dir
            - mountPath: /host/etc/cni/net.d
              name: cni-net-dir
      volumes:
        - name: etcd-ca-certs
          hostPath:
            path: /etc/etcd/ssl
            type: DirectoryOrCreate
        - name: kubernetes-ca-certs
          hostPath:
            path: /etc/kubernetes/ssl
            type: DirectoryOrCreate
        - name: lib-modules
          hostPath:
            path: /lib/modules
        - name: var-run-calico
          hostPath:
            path: /var/run/calico
        - name: cni-bin-dir
          hostPath:
            path: /opt/cni/bin
        - name: cni-net-dir
          hostPath:
            path: /etc/cni/net.d
---
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: calico-kube-controllers
  namespace: kube-system
  labels:
    k8s-app: calico-kube-controllers
spec:
  replicas: 1
  strategy:
    type: Recreate
  template:
    metadata:
      name: calico-kube-controllers
      namespace: kube-system
      labels:
        k8s-app: calico-kube-controllers
      annotations:
        scheduler.alpha.kubernetes.io/critical-pod: ''
    spec:
      hostNetwork: true
      tolerations:
      - key: node.cloudprovider.kubernetes.io/uninitialized
        value: "true"
        effect: NoSchedule
      - key: node-role.kubernetes.io/master
        effect: NoSchedule
      - key: CriticalAddonsOnly
        operator: Exists
      serviceAccountName: calico-kube-controllers
      containers:
        - name: calico-kube-controllers
          image: quay.io/calico/kube-controllers:v2.0.2
          env:
            - name: ETCD_ENDPOINTS
              valueFrom:
                configMapKeyRef:
                  name: calico-config
                  key: etcd_endpoints
            - name: ENABLED_CONTROLLERS
              value: policy,profile,workloadendpoint,node
            - name: ETCD_CA_CERT_FILE
              value: "/etc/kubernetes/ssl/ca.pem"
            - name: ETCD_CERT_FILE
              value: "/etc/etcd/ssl/etcd.pem"
            - name: ETCD_KEY_FILE
              value: "/etc/etcd/ssl/etcd-key.pem"
          volumeMounts:
            - mountPath: /etc/etcd/ssl
              name: etcd-ca-certs
              readOnly: true
            - mountPath: /etc/kubernetes/ssl
              name: kubernetes-ca-certs
              readOnly: true
      volumes:
        - name: etcd-ca-certs
          hostPath:
            path: /etc/etcd/ssl
            type: DirectoryOrCreate
        - name: kubernetes-ca-certs
          hostPath:
            path: /etc/kubernetes/ssl
            type: DirectoryOrCreate

---
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  name: calico-cni-plugin
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: calico-cni-plugin
subjects:
- kind: ServiceAccount
  name: calico-cni-plugin
  namespace: kube-system
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: calico-cni-plugin
rules:
  - apiGroups: [""]
    resources:
      - pods
      - nodes
    verbs:
      - get
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: calico-cni-plugin
  namespace: kube-system
---
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  name: calico-kube-controllers
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: calico-kube-controllers
subjects:
- kind: ServiceAccount
  name: calico-kube-controllers
  namespace: kube-system
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: calico-kube-controllers
rules:
  - apiGroups:
    - ""
    - extensions
    resources:
      - pods
      - namespaces
      - networkpolicies
      - nodes
    verbs:
      - watch
      - list
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: calico-kube-controllers
  namespace: kube-system
EOF

安装插件：

$ kubectl create -f /etc/kubernetes/network/calico.yml
configmap "calico-config" created
daemonset.extensions "calico-node" created
deployment.extensions "calico-kube-controllers" created
clusterrolebinding.rbac.authorization.k8s.io "calico-cni-plugin" created
clusterrole.rbac.authorization.k8s.io "calico-cni-plugin" created
serviceaccount "calico-cni-plugin" created
clusterrolebinding.rbac.authorization.k8s.io "calico-kube-controllers" created
clusterrole.rbac.authorization.k8s.io "calico-kube-controllers" created
serviceaccount "calico-kube-controllers" created

$ kubectl -n kube-system get po -l k8s-app=calico-node -o wide
NAME                READY     STATUS    RESTARTS   AGE       IP              NODE
calico-node-hjghp   2/2       Running   0          9m        192.168.56.16   kube-n3
calico-node-jl9w2   2/2       Running   0          9m        192.168.56.12   kube-m2
calico-node-k4lkr   2/2       Running   0          9m        192.168.56.14   kube-n1
calico-node-kj9xd   2/2       Running   0          9m        192.168.56.15   kube-n2
calico-node-mf2xv   2/2       Running   0          9m        192.168.56.11   kube-m1
calico-node-p8pqq   2/2       Running   0          9m        192.168.56.13   kube-m3

查看刚刚 DNS 处于 Pending 的 Pod 是否已经启动：

$ kubectl -n kube-system get po -l k8s-app=kube-dns
NAME                        READY     STATUS    RESTARTS   AGE
kube-dns-654684d656-vzkjk   3/3       Running   0          25m

在 kube-m1 下载 Calico CLI 来查看 Calico nodes:

$ wget https://github.com/projectcalico/calicoctl/releases/download/v3.1.0/calicoctl -O /usr/local/bin/calicoctl

$ chmod u+x /usr/local/bin/calicoctl

$ cat <<EOF > ~/calico-rc
export ETCD_ENDPOINTS="https://192.168.56.11:2379,https://192.168.56.12:2379,https://192.168.56.13:2379"
export ETCD_CA_CERT_FILE="/etc/kubernetes/ssl/ca.pem"
export ETCD_CERT_FILE="/etc/etcd/ssl/etcd.pem"
export ETCD_KEY_FILE="/etc/etcd/ssl/etcd-key.pem"
EOF

$ calicoctl node status
Calico process is running.

IPv4 BGP status
+---------------+-------------------+-------+----------+-------------+
| PEER ADDRESS  |     PEER TYPE     | STATE |  SINCE   |    INFO     |
+---------------+-------------------+-------+----------+-------------+
| 192.168.56.12 | node-to-node mesh | up    | 06:59:37 | Established |
| 192.168.56.13 | node-to-node mesh | up    | 06:59:38 | Established |
| 192.168.56.14 | node-to-node mesh | up    | 07:04:57 | Established |
| 192.168.56.15 | node-to-node mesh | up    | 07:06:35 | Established |
| 192.168.56.16 | node-to-node mesh | up    | 07:07:06 | Established |
+---------------+-------------------+-------+----------+-------------+

IPv6 BGP status
No IPv6 peers found.

虚拟机部署 Kubernetes v1.10.3 高可用集群 - 03 部署 Master

Wed, 30 May 2018 17:44:00 GMT

本部分将说明如何建立与设定 Kubernetes Master 角色，过程中会部署以下元件：

kube-apiserver：提供 REST APIs，包含授权、认证与状态储存等。
kube-controller-manager：负责维护集群的状态，如自动扩展，滚动更新等。
kube-scheduler：负责资源排程，依据预定的排程策略将 Pod 分配到对应节点上。
Etcd：储存集群所有状态的 Key/Value 储存系统。
HAProxy：提供负载平衡器。
Keepalived：提供虚拟网络位址 (VIP)。

部署和设定

首先在所有 Master 节点下载部署元件的 YAML 文件，这边不采用二进制执行档与 Systemd 来管理这些元件，全部采用 Static Pod 来达成。这边将配置文件放到 /etc/kubernetes/manifests 目录。

以下所有操作需要在每个 Master 上都操作。

$ mkdir -p /etc/kubernetes/manifests && cd /etc/kubernetes/manifests

$ # 替换为当前部署的 master 机器 IP
$ export MASTER_IP=192.168.56.11

kube-apiserver 配置

$ cat > /etc/kubernetes/manifests/kube-apiserver.yaml <<EOF
apiVersion: v1
kind: Pod
metadata:
  annotations:
    scheduler.alpha.kubernetes.io/critical-pod: ""
  labels:
    component: kube-apiserver
    tier: control-plane
  name: kube-apiserver
  namespace: kube-system
spec:
  hostNetwork: true
  containers :
  - name: kube-apiserver
    image: gcr.io/google_containers/kube-apiserver-amd64:v1.10.3
    command:
      - kube-apiserver
      - --v=0
      - --logtostderr=true
      - --allow-privileged=true
      - --advertise-address=${MASTER_IP}
      - --bind-address=${MASTER_IP}
      - --insecure-bind-address=${MASTER_IP}
      - --secure-port=5443
      - --insecure-port=7070
      - --service-cluster-ip-range=10.254.0.0/16
      - --service-node-port-range=30000-32767
      - --etcd-servers=https://192.168.56.11:2379,https://192.168.56.12:2379,https://192.168.56.13:2379
      - --etcd-cafile=/etc/kubernetes/ssl/ca.pem
      - --etcd-certfile=/etc/etcd/ssl/etcd.pem
      - --etcd-keyfile=/etc/etcd/ssl/etcd-key.pem
      - --client-ca-file=/etc/kubernetes/ssl/ca.pem
      - --tls-cert-file=/etc/kubernetes/ssl/apiserver.pem
      - --tls-private-key-file=/etc/kubernetes/ssl/apiserver-key.pem
      - --kubelet-client-certificate=/etc/kubernetes/ssl/apiserver.pem
      - --kubelet-client-key=/etc/kubernetes/ssl/apiserver-key.pem
      - --service-account-key-file=/etc/kubernetes/ssl/sa.pub
      - --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname
      - --admission-control=Initializers,NamespaceLifecycle,LimitRanger,ServiceAccount,DefaultStorageClass,DefaultTolerationSeconds,NodeRestriction,ResourceQuota
      - --authorization-mode=Node,RBAC
      - --enable-bootstrap-token-auth=true
      - --requestheader-client-ca-file=/etc/kubernetes/ssl/ca.pem
      - --proxy-client-cert-file=/etc/kubernetes/ssl/front-proxy-client.pem
      - --proxy-client-key-file=/etc/kubernetes/ssl/front-proxy-client-key.pem
      - --requestheader-allowed-names=aggregator
      - --requestheader-group-headers=X-Remote-Group
      - --requestheader-extra-headers-prefix=X-Remote-Extra-
      - --requestheader-username-headers=X-Remote-User
      - --audit-log-maxage=30
      - --audit-log-maxbackup=3
      - --audit-log-maxsize=100
      - --audit-log-path=/var/log/kubernetes/audit.log
      - --audit-policy-file=/etc/kubernetes/audit-policy.yml
      - --experimental-encryption-provider-config=/etc/kubernetes/encryption.yml
      - --event-ttl=1h
    livenessProbe:
      failureThreshold: 8
      httpGet:
        host: 127.0.0.1
        path: /healthz
        port: 6443
        scheme: HTTPS
      initialDelaySeconds: 15
      timeoutSeconds: 15
    resources:
      requests:
        cpu: 250m
    volumeMounts:
    - mountPath: /var/log/kubernetes
      name: k8s-audit-log
    - mountPath: /etc/kubernetes/ssl
      name: k8s-certs
      readOnly: true
    - mountPath: /etc/ssl/certs
      name: ca-certs
      readOnly: true
    - mountPath: /etc/kubernetes/encryption.yml
      name: encryption-config
      readOnly: true
    - mountPath: /etc/kubernetes/audit-policy.yml
      name: audit-config
      readOnly: true
    - mountPath: /etc/etcd/ssl
      name: etcd-ca-certs
      readOnly: true
  volumes:
  - hostPath:
      path: /var/log/kubernetes
      type: DirectoryOrCreate
    name: k8s-audit-log
  - hostPath:
      path: /etc/kubernetes/ssl
      type: DirectoryOrCreate
    name: k8s-certs
  - hostPath:
      path: /etc/kubernetes/encryption.yml
      type: FileOrCreate
    name: encryption-config
  - hostPath:
      path: /etc/kubernetes/audit-policy.yml
      type: FileOrCreate
    name: audit-config
  - hostPath:
      path: /etc/ssl/certs
      type: DirectoryOrCreate
    name: ca-certs
  - hostPath:
      path: /etc/etcd/ssl
      type: DirectoryOrCreate
    name: etcd-ca-certs
EOF

kube-apiserver 中的NodeRestriction 请参考 Using Node Authorization

产生一个用来加密 Etcd 的 Key:

$  head -c 32 /dev/urandom | base64
TUkHNhh1j+DKsnW3VWK8ZVmfQy3i9a/VaRuoqgha4F4=

注意每台master节点需要用一样的 Key

在 /etc/kubernetes 目录下建立 encryption.yml 的加密 YAML 文件：

$ cat <<EOF > /etc/kubernetes/encryption.yml
kind: EncryptionConfig
apiVersion: v1
resources:
  - resources:
      - secrets
    providers:
      - aescbc:
          keys:
            - name: key1
              secret: TUkHNhh1j+DKsnW3VWK8ZVmfQy3i9a/VaRuoqgha4F4=
      - identity: {}
EOF

Etcd 资料加密可参考 Encrypting data at rest

在/etc/kubernetes/目录下，建立audit-policy.yml的审计策略 YAML 文件：

$ cat <<EOF > /etc/kubernetes/audit-policy.yml
apiVersion: audit.k8s.io/v1beta1
kind: Policy
rules:
  - level: Metadata
EOF

Audit Policy 请参考 Auditing

kube-controller-manager 配置

$ cat > /etc/kubernetes/manifests/kube-controller-manager.yml <<EOF
apiVersion: v1
kind: Pod
metadata:
  annotations:
    scheduler.alpha.kubernetes.io/critical-pod: ""
  labels:
    component: kube-controller-manager
    tier: control-plane
  name: kube-controller-manager
  namespace: kube-system
spec:
  hostNetwork: true
  containers:
  - name: kube-controller-manager
    image: gcr.io/google_containers/kube-controller-manager-amd64:v1.10.3
    command:
      - kube-controller-manager
      - --v=0
      - --logtostderr=true
      - --address=127.0.0.1
      - --root-ca-file=/etc/kubernetes/ssl/ca.pem
      - --cluster-signing-cert-file=/etc/kubernetes/ssl/ca.pem
      - --cluster-signing-key-file=/etc/kubernetes/ssl/ca-key.pem
      - --service-account-private-key-file=/etc/kubernetes/ssl/sa.key
      - --kubeconfig=/etc/kubernetes/controller-manager.conf
      - --leader-elect=true
      - --use-service-account-credentials=true
      - --node-monitor-grace-period=40s
      - --node-monitor-period=5s
      - --pod-eviction-timeout=2m0s
      - --controllers=*,bootstrapsigner,tokencleaner
      - --allocate-node-cidrs=true
      - --cluster-cidr=172.30.0.0/16
      - --service-cluster-ip-range=10.254.0.0/16
      - --node-cidr-mask-size=24
    livenessProbe:
      failureThreshold: 8
      httpGet:
        host: 127.0.0.1
        path: /healthz
        port: 10252
        scheme: HTTP
      initialDelaySeconds: 15
      timeoutSeconds: 15
    resources:
      requests:
        cpu: 200m
    volumeMounts:
    - mountPath: /etc/kubernetes/ssl
      name: k8s-certs
      readOnly: true
    - mountPath: /etc/ssl/certs
      name: ca-certs
      readOnly: true
    - mountPath: /etc/kubernetes/controller-manager.conf
      name: kubeconfig
      readOnly: true
    - mountPath: /usr/libexec/kubernetes/kubelet-plugins/volume/exec
      name: flexvolume-dir
  volumes:
  - hostPath:
      path: /etc/kubernetes/ssl
      type: DirectoryOrCreate
    name: k8s-certs
  - hostPath:
      path: /etc/ssl/certs
      type: DirectoryOrCreate
    name: ca-certs
  - hostPath:
      path: /etc/kubernetes/controller-manager.conf
      type: FileOrCreate
    name: kubeconfig
  - hostPath:
      path: /usr/libexec/kubernetes/kubelet-plugins/volume/exec
      type: DirectoryOrCreate
    name: flexvolume-dir
EOF

kube-scheduler 配置

$ cat > /etc/kubernetes/manifests/kube-scheduler.yml <<EOF
apiVersion: v1
kind: Pod
metadata:
  annotations:
    scheduler.alpha.kubernetes.io/critical-pod: ""
  labels:
    component: kube-scheduler
    tier: control-plane
  name: kube-scheduler
  namespace: kube-system
spec:
  hostNetwork: true
  containers:
  - name: kube-scheduler
    image: gcr.io/google_containers/kube-scheduler-amd64:v1.10.3
    command:
      - kube-scheduler
      - --v=0
      - --logtostderr=true
      - --address=127.0.0.1
      - --leader-elect=true
      - --kubeconfig=/etc/kubernetes/scheduler.conf
    livenessProbe:
      failureThreshold: 8
      httpGet:
        host: 127.0.0.1
        path: /healthz
        port: 10251
        scheme: HTTP
      initialDelaySeconds: 15
      timeoutSeconds: 15
    resources:
      requests:
        cpu: 100m
    volumeMounts:
    - mountPath: /etc/kubernetes/ssl
      name: k8s-certs
      readOnly: true
    - mountPath: /etc/kubernetes/scheduler.conf
      name: kubeconfig
      readOnly: true
  volumes:
  - hostPath:
      path: /etc/kubernetes/ssl
      type: DirectoryOrCreate
    name: k8s-certs
  - hostPath:
      path: /etc/kubernetes/scheduler.conf
      type: FileOrCreate
    name: kubeconfig
EOF

etcd 配置

$ cat > /etc/kubernetes/manifests/etcd.yml <<EOF
apiVersion: v1
kind: Pod
metadata:
  annotations:
    scheduler.alpha.kubernetes.io/critical-pod: ""
  labels:
    component: etcd
    tier: control-plane
  name: etcd
  namespace: kube-system
spec:
  hostNetwork: true
  containers:
  - name: etcd
    image: gcr.io/google_containers/etcd-amd64:3.1.13
    command:
    - etcd
    - --config-file=/etc/etcd/etcd.config.yml
    livenessProbe:
      failureThreshold: 8
      tcpSocket:
        port: 2379
      initialDelaySeconds: 15
      timeoutSeconds: 15
    volumeMounts:
    - mountPath: /etc/etcd/ssl
      name: etcd-certs
    - mountPath: /etc/kubernetes/ssl
      name: kubernetes-certs
    - mountPath: /etc/etcd/etcd.config.yml
      name: etcd-conf
    - mountPath: /var/lib/etcd
      name: data
  volumes:
  - hostPath:
      path: /etc/etcd/ssl
      type: DirectoryOrCreate
    name: etcd-certs
  - hostPath:
      path: /etc/kubernetes/ssl
      type: DirectoryOrCreate
    name: kubernetes-certs
  - hostPath:
      path: /etc/etcd/etcd.config.yml
    name: etcd-conf
  - hostPath:
      path: /var/lib/etcd
      type: DirectoryOrCreate
    name: data
EOF

etcd.config.yml:

$ cat > /etc/etcd/etcd.config.yml <<EOF
name: '${HOSTNAME}'
data-dir: /var/lib/etcd
wal-dir: /var/lib/etcd/wal
snapshot-count: 10000
heartbeat-interval: 100
election-timeout: 1000
quota-backend-bytes: 0
listen-peer-urls: 'https://0.0.0.0:2380'
listen-client-urls: 'https://0.0.0.0:2379'
max-snapshots: 5
max-wals: 5
cors:
initial-advertise-peer-urls: 'https://${MASTER_IP}:2380'
advertise-client-urls: 'https://${MASTER_IP}:2379'
discovery:
discovery-fallback: 'proxy'
discovery-proxy:
discovery-srv:
initial-cluster: 'kube-m1=https://192.168.56.11:2380,kube-m2=https://192.168.56.12:2380,kube-m3=https://192.168.56.13:2380'
initial-cluster-token: 'etcd-k8s-cluster'
initial-cluster-state: 'new'
strict-reconfig-check: false
enable-v2: true
enable-pprof: true
proxy: 'off'
proxy-failure-wait: 5000
proxy-refresh-interval: 30000
proxy-dial-timeout: 1000
proxy-write-timeout: 5000
proxy-read-timeout: 0
client-transport-security:
  ca-file: '/etc/kubernetes/ssl/ca.pem'
  cert-file: '/etc/etcd/ssl/etcd.pem'
  key-file: '/etc/etcd/ssl/etcd-key.pem'
  client-cert-auth: true
  trusted-ca-file: '/etc/kubernetes/ssl/ca.pem'
  auto-tls: true
peer-transport-security:
  ca-file: '/etc/kubernetes/ssl/ca.pem'
  cert-file: '/etc/etcd/ssl/etcd.pem'
  key-file: '/etc/etcd/ssl/etcd-key.pem'
  peer-client-cert-auth: true
  trusted-ca-file: '/etc/kubernetes/ssl/ca.pem'
  auto-tls: true
debug: false
log-package-levels:
log-output: default
force-new-cluster: false
EOF

haproxy 配置

$ cat > /etc/kubernetes/manifests/haproxy.yml <<EOF
kind: Pod
apiVersion: v1
metadata:
  annotations:
    scheduler.alpha.kubernetes.io/critical-pod: ""
  labels:
    component: haproxy
    tier: control-plane
  name: haproxy
  namespace: kube-system
spec:
  hostNetwork: true
  containers:
  - name: haproxy
    image: kairen/haproxy:1.7
    resources:
      requests:
        cpu: 100m
    volumeMounts:
    - name: cfg-volume
      readOnly: true
      mountPath: "/usr/local/etc/haproxy/haproxy.cfg"
  volumes:
  - name: cfg-volume
    hostPath:
      path: "/etc/haproxy/haproxy.cfg"
EOF

haproxy.cfg：

$ mkdir -p /etc/haproxy

$ cat > /etc/haproxy/haproxy.cfg <<EOF
global
  log 127.0.0.1 local0
  log 127.0.0.1 local1 notice
  tune.ssl.default-dh-param 2048

defaults
  log global
  mode http
  #option httplog
  option dontlognull
  timeout connect 5000ms
  timeout client 50000ms
  timeout server 50000ms

listen stats
    bind :9090
    mode http
    balance
    stats uri /haproxy_stats
    stats auth admin:admin123
    stats admin if TRUE

frontend api-https
   mode tcp
   bind :6443
   default_backend https-backend

frontend api-http
   mode tcp
   bind :8080
   default_backend http-backend

backend https-backend
    mode tcp
    server  api1  192.168.56.11:5443  check
    server  api2  192.168.56.12:5443  check
    server  api3  192.168.56.13:5443  check

backend http-backend
    mode tcp
    server  api1  192.168.56.11:7070  check
    server  api2  192.168.56.12:7070  check
    server  api3  192.168.56.13:7070  check
EOF

keepalived 配置

$ cat > /etc/kubernetes/manifests/keepalived.yml <<EOF
kind: Pod
apiVersion: v1
metadata:
  annotations:
    scheduler.alpha.kubernetes.io/critical-pod: ""
  labels:
    component: keepalived
    tier: control-plane
  name: keepalived
  namespace: kube-system
spec:
  hostNetwork: true
  containers:
  - name: keepalived
    image: kairen/keepalived:1.2.24
    env:
    - name: VIRTUAL_IP
      value: 192.168.56.10
    - name: INTERFACE
      value: eth1
    - name: VIRTUAL_MASK
      value: "24"
    - name: CHECK_IP
      value: any
    - name: CHECK_PORT
      value: "2379"
    - name: VRID
      value: "53"
    resources:
      requests:
        cpu: 100m
    securityContext:
      privileged: true
      capabilities:
        add:
        - NET_ADMIN
EOF

kubelet.service 配置

安装 cni 网络插件：

$ mkdir -p /opt/cni/bin && cd /opt/cni/bin
$ export CNI_URL="https://github.com/containernetworking/plugins/releases/download"
$ wget -qO- "${CNI_URL}/v0.6.0/cni-plugins-amd64-v0.6.0.tgz" | tar -zx

kubelet.service：

$ cat > /usr/lib/systemd/system/kubelet.service <<EOF
[Unit]
Description=Kubernetes Kubelet
Documentation=https://github.com/GoogleCloudPlatform/kubernetes
After=docker.service
Requires=docker.service

[Service]
Environment="KUBELET_KUBECONFIG_ARGS=--kubeconfig=/etc/kubernetes/kubelet.conf"
Environment="KUBELET_SYSTEM_PODS_ARGS=--pod-manifest-path=/etc/kubernetes/manifests --allow-privileged=true"
Environment="KUBELET_NETWORK_ARGS=--network-plugin=cni --cni-conf-dir=/etc/cni/net.d --cni-bin-dir=/opt/cni/bin"
Environment="KUBELET_DNS_ARGS=--cluster-dns=10.254.0.2 --cluster-domain=cluster.local"
Environment="KUBELET_AUTHZ_ARGS=--authorization-mode=Webhook --client-ca-file=/etc/kubernetes/ssl/ca.pem"
Environment="KUBELET_CADVISOR_ARGS=--cadvisor-port=0"
Environment="KUBELET_CERTIFICATE_ARGS=--rotate-certificates=true --cert-dir=/var/lib/kubelet/ssl"
Environment="KUBELET_EXTRA_ARGS=--node-labels=node-role.kubernetes.io/master='' --logtostderr=true --v=0 --fail-swap-on=false --cgroup-driver=systemd"
ExecStart=/usr/local/bin/kubelet \$KUBELET_KUBECONFIG_ARGS \$KUBELET_SYSTEM_PODS_ARGS \$KUBELET_NETWORK_ARGS \$KUBELET_DNS_ARGS \$KUBELET_AUTHZ_ARGS \$KUBELET_CADVISOR_ARGS \$KUBELET_CERTIFICATE_ARGS \$KUBELET_EXTRA_ARGS
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target
EOF

启动 kubelet

$ mkdir -p /var/lib/kubelet /var/log/kubernetes /var/lib/etcd

$ systemctl enable kubelet.service && systemctl start kubelet.service

验证集群

完成后，在任意一台master节点复制 admin kubeconfig 文件，并通过简单指令验证：

$ cp /etc/kubernetes/admin.conf ~/.kube/config

$ kubectl get cs
NAME                 STATUS    MESSAGE              ERROR
controller-manager   Healthy   ok
scheduler            Healthy   ok
etcd-2               Healthy   {"health": "true"}
etcd-1               Healthy   {"health": "true"}
etcd-0               Healthy   {"health": "true"}

$ kubectl get node
NAME      STATUS     ROLES     AGE       VERSION
kube-m1    NotReady   master    52s       v1.10.3
kube-m2    NotReady   master    51s       v1.10.3
kube-m3    NotReady   master    50s       v1.10.3

接着确认服务能够执行 logs 等指令:

$ kubectl -n kube-system logs -f kube-scheduler-kube-m1
Error from server (Forbidden): Forbidden (user=kubernetes, verb=get, resource=nodes, subresource=proxy) ( pods/log kube-scheduler-kube-m1)

这边会发现出现 403 Forbidden 问题，这是因为 kube-apiserver user 并没有 nodes 的资源存取权限，属于正常。

由于上述权限问题，必需建立一个apiserver-to-kubelet-rbac.yml来定义权限，以供对 Nodes 容器执行 logs、exec 等指令。在任意一台master节点执行以下指令：

$ cat > apiserver-to-kubelet-rbac.yml <<EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  annotations:
    rbac.authorization.kubernetes.io/autoupdate: "true"
  labels:
    kubernetes.io/bootstrapping: rbac-defaults
  name: system:kube-apiserver-to-kubelet
rules:
  - apiGroups:
      - ""
    resources:
      - nodes/proxy
      - nodes/stats
      - nodes/log
      - nodes/spec
      - nodes/metrics
    verbs:
      - "*"
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: system:kube-apiserver
  namespace: ""
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:kube-apiserver-to-kubelet
subjects:
  - apiGroup: rbac.authorization.k8s.io
    kind: User
    name: kube-apiserver
EOF

$ kubectl apply -f apiserver-to-kubelet-rbac.yml
clusterrole.rbac.authorization.k8s.io "system:kube-apiserver-to-kubelet" created
clusterrolebinding.rbac.authorization.k8s.io "system:kube-apiserver" created

$ # 测试 logs
$ kubectl -n kube-system logs -f kube-scheduler-kube-m1

设定master节点允许 Taint：

$ kubectl taint nodes node-role.kubernetes.io/master="":NoSchedule --all
node "kube-m1" tainted
node "kube-m2" tainted
node "kube-m3" tainted

建立 TLS Bootstrapping RBAC 与 Secret

由于本次安装启用了 TLS 认证，因此每个节点的 kubelet 都必须使用 kube-apiserver 的 CA 的凭证后，才能与 kube-apiserver 进行沟通，而该过程需要手动针对每台节点单独签署凭证是一件繁琐的事情，且一旦节点增加会延伸出管理不易问题; 而 TLS bootstrapping 目标就是解决该问题，通过让 kubelet 先使用一个预定低权限使用者连接到 kube-apiserver，然后在对 kube-apiserver 申请凭证签署，当授权 Token 一致时，Node 节点的 kubelet 凭证将由 kube-apiserver 动态签署提供。具体作法可以参考 TLS Bootstrapping 与 Authenticating with Bootstrap Tokens。

首先在 kube-m1 建立一个变量来产生BOOTSTRAP_TOKEN，并建立bootstrap-kubelet.conf的 Kubernetes config 档：

$ cd /etc/kubernetes/ssl
$ export TOKEN_ID=$(openssl rand 3 -hex)
$ export TOKEN_SECRET=$(openssl rand 8 -hex)
$ export BOOTSTRAP_TOKEN=${TOKEN_ID}.${TOKEN_SECRET}
$ export KUBE_APISERVER="https://192.168.56.10:6443"
$ # 设置集群参数
$ kubectl config set-cluster kubernetes \
    --certificate-authority=ca.pem \
    --embed-certs=true \
    --server=${KUBE_APISERVER} \
    --kubeconfig=../bootstrap-kubelet.conf
$ # 设置客户端认证参数
$ kubectl config set-credentials tls-bootstrap-token-user \
    --token=${BOOTSTRAP_TOKEN} \
    --kubeconfig=../bootstrap-kubelet.conf
$ # 设置上下文参数
$ kubectl config set-context tls-bootstrap-token-user@kubernetes \
    --cluster=kubernetes \
    --user=tls-bootstrap-token-user \
    --kubeconfig=../bootstrap-kubelet.conf
$ # 设置默认上下文
$ kubectl config use-context tls-bootstrap-token-user@kubernetes \
    --kubeconfig=../bootstrap-kubelet.conf

接着在 kube-m1 建立 TLS bootstrap secret 来提供自动签证使用：

$ cat <<EOF | kubectl create -f -
apiVersion: v1
kind: Secret
metadata:
  name: bootstrap-token-${TOKEN_ID}
  namespace: kube-system
type: bootstrap.kubernetes.io/token
stringData:
  token-id: ${TOKEN_ID}
  token-secret: ${TOKEN_SECRET}
  usage-bootstrap-authentication: "true"
  usage-bootstrap-signing: "true"
  auth-extra-groups: system:bootstrappers:default-node-token
EOF
secret "bootstrap-token-ea4387" created

# 在 kube-m1 建立 TLS Bootstrap Autoapprove RBAC：

$ cat <<EOF | kubectl create -f -
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: kubelet-bootstrap
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:node-bootstrapper
subjects:
- apiGroup: rbac.authorization.k8s.io
  kind: Group
  name: system:bootstrappers:default-node-token
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: node-autoapprove-bootstrap
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:certificates.k8s.io:certificatesigningrequests:nodeclient
subjects:
- apiGroup: rbac.authorization.k8s.io
  kind: Group
  name: system:bootstrappers:default-node-token
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: node-autoapprove-certificate-rotation
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:certificates.k8s.io:certificatesigningrequests:selfnodeclient
subjects:
- apiGroup: rbac.authorization.k8s.io
  kind: Group
  name: system:nodes
EOF
clusterrolebinding.rbac.authorization.k8s.io "kubelet-bootstrap" created
clusterrolebinding.rbac.authorization.k8s.io "node-autoapprove-bootstrap" created
clusterrolebinding.rbac.authorization.k8s.io "node-autoapprove-certificate-rotation" created

虚拟机部署 Kubernetes v1.10.3 高可用集群 - 02 生成证书

Wed, 30 May 2018 17:43:00 GMT

在这个部分，将需要产生多个元件的 Certificates，这包含 Etcd、Kubernetes 元件等，并且每个集群都会有一个根数位凭证认证机构 (Root Certificate Authority) 被用在认证 API Server 与 Kubelet 端的凭证。

P.S. 这边要注意 CA JSON 档的 CN(Common Name)与O(Organization) 等内容是会影响 Kubernetes 元件认证的。

准备工作

在主机 kube-m1 上安装 cfssl ，在任意目录执行以下命令：

$ wget https://pkg.cfssl.org/R1.3.2/cfssl_linux-amd64 && chmod +x cfssl_linux-amd64 && mv cfssl_linux-amd64 /usr/local/bin/cfssl

$ wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 && chmod +x cfssljson_linux-amd64 && mv cfssljson_linux-amd64 /usr/local/bin/cfssljson

$ wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 && chmod +x cfssl-certinfo_linux-amd64 && mv cfssl-certinfo_linux-amd64 /usr/local/bin/cfssl-certinfo

创建 CA 证书和秘钥

CA 证书 k8s 和 etcd 共用一份，放在 /etc/kubernetes/ssl 下。

创建证书文件夹

mkdir -p /etc/kubernetes/ssl && cd /etc/kubernetes/ssl

创建 CA 配置文件：

$ cat > ca-config.json <<EOF
{
  "signing": {
    "default": {
      "expiry": "8760h"
    },
    "profiles": {
      "kubernetes": {
        "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ],
        "expiry": "8760h"
      }
    }
  }
}
EOF

ca-config.json：可以定义多个 profiles，分别指定不同的过期时间、使用场景等参数；后续在签名证书时使用某个 profile；
signing：表示该证书可用于签名其它证书；生成的 ca.pem 证书中 CA=TRUE；
server auth：表示 client 可以用该 CA 对 server 提供的证书进行验证；
client auth：表示 server 可以用该 CA 对 client 提供的证书进行验证。

创建 CA 证书签名请求：

$ cat > ca-csr.json <<EOF
{
  "CN": "kubernetes",
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "ShenZhen",
      "L": "ShenZhen",
      "O": "Kubernetes",
      "OU": "4Paradigm"
    }
  ]
}
EOF

CN”：Common Name，kube-apiserver 从证书中提取该字段作为请求的用户名 (User Name)；浏览器使用该字段验证网站是否合法；
“O”：Organization，kube-apiserver 从证书中提取该字段作为请求用户所属的组 (Group)；

生成 CA keys 与 Certificate

$ cfssl gencert -initca ca-csr.json | cfssljson -bare ca
$ ls ca*
ca-config.json  ca.csr  ca-csr.json  ca-key.pem  ca.pem

Etcd

在此步骤中将创建与 Etcd 相关的证书文件。

创建 Etcd 证书文件夹

$ mkdir -p /etc/etcd/ssl && cd /etc/etcd/ssl

创建 TLS 秘钥和证书

为了保证通信安全，客户端(如 etcdctl) 与 etcd 集群、etcd 集群之间的通信需要使用 TLS 加密，本节创建 etcd TLS 加密所需的证书和私钥。

创建 etcd 证书签名请求：

$ cat > etcd-csr.json <<EOF
{
  "CN": "etcd",
  "hosts": [
    "127.0.0.1",
    "192.168.56.11",
    "192.168.56.12",
    "192.168.56.13"
  ],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "ShenZhen",
      "L": "ShenZhen",
      "O": "Kubernetes",
      "OU": "4Paradigm"
    }
  ]
}
EOF

hosts 字段指定授权使用该证书的 etcd 节点 IP，在这里指三台 Master 主机。

生成 etcd 证书和私钥：

$ cfssl gencert -ca=/etc/kubernetes/ssl/ca.pem \
  -ca-key=/etc/kubernetes/ssl/ca-key.pem \
  -config=/etc/kubernetes/ssl/ca-config.json \
  -profile=kubernetes etcd-csr.json | cfssljson -bare etcd

$ ls etcd*.pem
etcd-key.pem etcd.pem

分发文件

分发前先删除不必要文件：

$ cd /etc/etcd/ssl

$ rm -rf *.json *.csr

$ ls /etc/etcd/ssl
etcd-key.pem  etcd.pem

复制相关文件至其他 Etcd 节点，这边为所有master节点：

$ for NODE in kube-m2 kube-m3; do
    echo "--- $NODE ---"
    ssh ${NODE} "mkdir -p /etc/etcd/ssl"
    for FILE in etcd-key.pem  etcd.pem; do
      scp /etc/etcd/ssl/${FILE} ${NODE}:/etc/etcd/ssl/${FILE}
    done
done

Kubernetes

在此步骤中将创建与 Kubernetes 相关的证书文件。

回到证书文件夹

$ cd /etc/kubernetes/ssl

生成 kube-apiserver 凭证

创建 Api Server 证书签名请求:

$ cat > /etc/kubernetes/ssl/apiserver-csr.json <<EOF
{
  "CN": "kube-apiserver",
  "hosts": [
    "127.0.0.1",
    "192.168.56.10",
    "10.254.0.1",
    "kubernetes",
    "kubernetes.default",
    "kubernetes.default.svc",
    "kubernetes.default.svc.cluster",
    "kubernetes.default.svc.cluster.local"
  ],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "ShenZhen",
      "L": "ShenZhen",
      "O": "Kubernetes",
      "OU": "4Paradigm"
    }
  ]
}
EOF

192.168.56.10 为虚拟 IP；
10.254.0.1 为 kube-apiserver —service-cluster-ip-range 选项值指定的网段的第一个IP，如 “10.254.0.1”。

生成 Api Server 证书和私钥:

$ cd /etc/kubernetes/ssl && cfssl gencert -ca=/etc/kubernetes/ssl/ca.pem \
  -ca-key=/etc/kubernetes/ssl/ca-key.pem \
  -config=/etc/kubernetes/ssl/ca-config.json \
  -profile=kubernetes /etc/kubernetes/ssl/apiserver-csr.json | cfssljson -bare apiserver

$ ls apiserver*.pem
apiserver-key.pem  apiserver.pem

生成 Front Proxy 凭证

创建 Front Proxy 证书签名请求：

$ cat > /etc/kubernetes/ssl/front-proxy-client-csr.json <<EOF
{
  "CN": "front-proxy-client",
  "hosts": [],
  "key": {
    "algo": "rsa",
    "size": 2048
  }
}
EOF

生成 Front Proxy 证书和私钥:

$ cd /etc/kubernetes/ssl && cfssl gencert -ca=/etc/kubernetes/ssl/ca.pem \
  -ca-key=/etc/kubernetes/ssl/ca-key.pem \
  -config=/etc/kubernetes/ssl/ca-config.json \
  -profile=kubernetes /etc/kubernetes/ssl/front-proxy-client-csr.json | cfssljson -bare front-proxy-client

$ ls front-proxy-client*.pem
front-proxy-client-key.pem  front-proxy-client.pem

生成 admin 凭证

创建 admin 证书签名请求：

$ cat > /etc/kubernetes/ssl/admin-csr.json <<EOF
{
    "CN":"admin",
    "hosts": [],
    "key":{
        "algo":"rsa",
        "size":2048
    },
    "names":[{
        "C":"CN",
        "ST":"Shenzhen",
        "L":"Shenzhen",
        "O":"system:masters",
        "OU":"4Paradigm"
        }]
}
EOF

生成 admin 证书和私钥:

$ cd /etc/kubernetes/ssl && cfssl gencert -ca=/etc/kubernetes/ssl/ca.pem \
  -ca-key=/etc/kubernetes/ssl/ca-key.pem \
  -config=/etc/kubernetes/ssl/ca-config.json \
  -profile=kubernetes admin-csr.json | cfssljson -bare admin

$ ls admin*.pem
admin-key.pem  admin.pem

生成 kubectl kubeconfig 文件:

$ cd /etc/kubernetes

$ export KUBE_APISERVER="https://192.168.56.10:6443"

$ # 设置集群参数
$ kubectl config set-cluster kubernetes \
  --certificate-authority=/etc/kubernetes/ssl/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=/etc/kubernetes/admin.conf

$ # 设置客户端认证参数
$ kubectl config set-credentials kubernetes-admin \
  --client-certificate=/etc/kubernetes/ssl/admin.pem \
  --embed-certs=true \
  --client-key=/etc/kubernetes/ssl/admin-key.pem \
  --kubeconfig=/etc/kubernetes/admin.conf

$ # 设置上下文参数
$ kubectl config set-context kubernetes-admin@kubernetes \
  --cluster=kubernetes \
  --user=kubernetes-admin \
  --kubeconfig=/etc/kubernetes/admin.conf
  
$ # 设置默认上下文
$ kubectl config use-context kubernetes-admin@kubernetes \
  --kubeconfig=/etc/kubernetes/admin.conf

生成 Controller Manager 凭证

创建 Controller Manager 证书签名请求：

$ cat > /etc/kubernetes/ssl/controller-manager-csr.json <<EOF
{
    "CN":"system:kube-controller-manager",
    "hosts": [],
    "key":{
        "algo":"rsa",
        "size":2048
    },
    "names":[{
        "C":"CN",
        "ST":"Shenzhen",
        "L":"Shenzhen",
        "O":"system:kube-controller-manager",
        "OU":"4Paradigm"
        }]
}
EOF

生成 Controller Manager 证书和私钥:

$ cd /etc/kubernetes/ssl && cfssl gencert -ca=/etc/kubernetes/ssl/ca.pem \
  -ca-key=/etc/kubernetes/ssl/ca-key.pem \
  -config=/etc/kubernetes/ssl/ca-config.json \
  -profile=kubernetes controller-manager-csr.json | cfssljson -bare controller-manager

$ ls controller-manager*.pem
controller-manager-key.pem  controller-manager.pem

生成 Controller Manager kubeconfig 文件:

$ cd /etc/kubernetes

$ export KUBE_APISERVER="https://192.168.56.10:6443"

$ # 设置集群参数
$ kubectl config set-cluster kubernetes \
    --certificate-authority=/etc/kubernetes/ssl/ca.pem \
    --embed-certs=true \
    --server=${KUBE_APISERVER} \
    --kubeconfig=/etc/kubernetes/controller-manager.conf

$ # 设置客户端认证参数
$ kubectl config set-credentials system:kube-controller-manager \
    --client-certificate=/etc/kubernetes/ssl/controller-manager.pem \
    --client-key=/etc/kubernetes/ssl/controller-manager-key.pem \
    --embed-certs=true \
    --kubeconfig=/etc/kubernetes/controller-manager.conf

$ # 设置上下文参数
$ kubectl config set-context system:kube-controller-manager@kubernetes \
    --cluster=kubernetes \
    --user=system:kube-controller-manager \
    --kubeconfig=/etc/kubernetes/controller-manager.conf
  
$ # 设置默认上下文
$ kubectl config use-context system:kube-controller-manager@kubernetes \
    --kubeconfig=/etc/kubernetes/controller-manager.conf

生成 Scheduler 凭证

创建 Scheduler 证书签名请求：

$ cat > /etc/kubernetes/ssl/scheduler-csr.json <<EOF
{
    "CN":"system:kube-scheduler",
    "hosts": [],
    "key":{
        "algo":"rsa",
        "size":2048
    },
    "names":[{
        "C":"CN",
        "ST":"Shenzhen",
        "L":"Shenzhen",
        "O":"system:kube-scheduler",
        "OU":"4Paradigm"
        }]
}
EOF

生成 Scheduler 证书和私钥:

$ cd /etc/kubernetes/ssl && cfssl gencert -ca=/etc/kubernetes/ssl/ca.pem \
  -ca-key=/etc/kubernetes/ssl/ca-key.pem \
  -config=/etc/kubernetes/ssl/ca-config.json \
  -profile=kubernetes scheduler-csr.json | cfssljson -bare scheduler

$ ls scheduler*.pem
scheduler-key.pem  scheduler.pem

生成 Scheduler kubeconfig 文件:

$ cd /etc/kubernetes

$ export KUBE_APISERVER="https://192.168.56.10:6443"

$ # 设置集群参数
$ kubectl config set-cluster kubernetes \
    --certificate-authority=/etc/kubernetes/ssl/ca.pem \
    --embed-certs=true \
    --server=${KUBE_APISERVER} \
    --kubeconfig=/etc/kubernetes/scheduler.conf

$ # 设置客户端认证参数
$ kubectl config set-credentials system:kube-scheduler \
    --client-certificate=/etc/kubernetes/ssl/scheduler.pem \
    --client-key=/etc/kubernetes/ssl/scheduler-key.pem \
    --embed-certs=true \
    --kubeconfig=/etc/kubernetes/scheduler.conf

$ # 设置上下文参数
$ kubectl config set-context system:kube-scheduler@kubernetes \
    --cluster=kubernetes \
    --user=system:kube-scheduler \
    --kubeconfig=/etc/kubernetes/scheduler.conf
  
$ # 设置默认上下文
$ kubectl config use-context system:kube-scheduler@kubernetes \
    --kubeconfig=/etc/kubernetes/scheduler.conf

生成 Master Kubelet 凭证

创建 Master Kubelet 证书签名请求：

$ cat > /etc/kubernetes/ssl/kubelet-csr.json <<EOF
{
    "CN":"system:node:\$NODE",
    "hosts": [],
    "key":{
        "algo":"rsa",
        "size":2048
    },
    "names":[{
        "C":"CN",
        "ST":"Shenzhen",
        "L":"Shenzhen",
        "O":"system:nodes",
        "OU":"4Paradigm"
        }]
}
EOF

生成所有 Master Kubelet 证书和私钥:

$ cd /etc/kubernetes/ssl
$ for NODE in kube-m1 kube-m2 kube-m3; do
    echo "--- $NODE ---"
    cp kubelet-csr.json kubelet-$NODE-csr.json;
    sed -i "s/\$NODE/$NODE/g" kubelet-$NODE-csr.json;
    cfssl gencert \
      -ca=/etc/kubernetes/ssl/ca.pem \
      -ca-key=/etc/kubernetes/ssl/ca-key.pem \
      -config=/etc/kubernetes/ssl/ca-config.json \
      -hostname=$NODE \
      -profile=kubernetes \
      kubelet-$NODE-csr.json | cfssljson -bare kubelet-$NODE
done
$ ls kubelet*.pem
kubelet-kube-m1-key.pem  kubelet-kube-m1.pem  kubelet-kube-m2-key.pem  kubelet-kube-m2.pem  kubelet-kube-m3-key.pem  kubelet-kube-m3.pem

完成后复制 kubelet 凭证至其他 master 节点:

$ for NODE in kube-m2 kube-m3; do
    echo "--- $NODE ---"
    ssh ${NODE} "mkdir -p /etc/kubernetes/ssl"
    for FILE in kubelet-$NODE-key.pem kubelet-$NODE.pem ca.pem; do
      scp /etc/kubernetes/ssl/${FILE} ${NODE}:/etc/kubernetes/ssl/${FILE}
    done
done

生成 Kubelet kubeconfig 文件:

$ for NODE in kube-m1 kube-m2 kube-m3; do
    echo "--- $NODE ---"
    ssh ${NODE} "cd /etc/kubernetes/ssl && \
      kubectl config set-cluster kubernetes \
        --certificate-authority=ca.pem \
        --embed-certs=true \
        --server=${KUBE_APISERVER} \
        --kubeconfig=../kubelet.conf && \
      kubectl config set-cluster kubernetes \
        --certificate-authority=ca.pem \
        --embed-certs=true \
        --server=${KUBE_APISERVER} \
        --kubeconfig=../kubelet.conf && \
      kubectl config set-credentials system:node:${NODE} \
        --client-certificate=kubelet-${NODE}.pem \
        --client-key=kubelet-${NODE}-key.pem \
        --embed-certs=true \
        --kubeconfig=../kubelet.conf && \
      kubectl config set-context system:node:${NODE}@kubernetes \
        --cluster=kubernetes \
        --user=system:node:${NODE} \
        --kubeconfig=../kubelet.conf && \
      kubectl config use-context system:node:${NODE}@kubernetes \
        --kubeconfig=../kubelet.conf && \
      rm kubelet-${NODE}.pem kubelet-${NODE}-key.pem"
done

生成 Service Account 凭证

Service account 不是通过 CA 进行认证，因此不要通过 CA 来做 Service account key 的检查，这边建立一组 Private 与 Public 金钥提供给 Service account key 使用：

$ cd /etc/kubernetes/ssl
$ openssl genrsa -out sa.key 2048

$ openssl rsa -in sa.key -pubout -out sa.pub

$ ls sa.*
sa.key  sa.pub

分发文件

分发前先将无用的文件删除：

$ cd /etc/kubernetes/ssl
$ rm -rf *.json *.csr scheduler*.pem controller-manager*.pem admin*.pem kubelet*.pem

将凭证文件分发到其他 Master 节点：

$ for NODE in kube-m2 kube-m3; do
    echo "--- $NODE ---"
    for FILE in $(ls /etc/kubernetes/ssl/); do
      scp /etc/kubernetes/ssl/${FILE} ${NODE}:/etc/kubernetes/ssl/${FILE}
    done
done

复制 Kubernetes config 文件至其他master节点：

$ for NODE in kube-m2 kube-m3; do
    echo "--- $NODE ---"
    for FILE in admin.conf controller-manager.conf scheduler.conf; do
      scp /etc/kubernetes/${FILE} ${NODE}:/etc/kubernetes/${FILE}
    done
done

虚拟机部署 Kubernetes v1.10.3 高可用集群 - 01 虚拟机环境准备

Wed, 30 May 2018 17:42:00 GMT

使用 Vagrant 管理虚拟机集群，下边是安装步骤。

文件准备

目录结构如下：

├── setup.sh
├── Vagrantfile
└── yum
    └── CentOS7-Base-163.repo

Vagrantfile：

def set_vbox(vb, config)
  vb.gui = false
  vb.memory = 1024
  vb.cpus = 1
end

Vagrant.configure("2") do |config|
  config.vm.box_check_update = false
  # 设置虚拟机的 Box
  config.vm.box = "centos/7"
  (1..6).each do |i|
    name = (i <= 3) ? "kube-m" : "kube-n"
    id = (i <= 3) ? i : i - 3
    config.vm.define "#{name}#{id}" do |n|
      n.vm.hostname = "#{name}#{id}"
      ip_addr = "192.168.56.#{i + 10}"
      n.vm.network :private_network, ip: "#{ip_addr}", auto_config: true
      n.vm.provider :virtualbox do |vb, override|
        vb.name = "#{n.vm.hostname}"
        set_vbox(vb, override)
      end
    end
  end
  # 使用shell脚本进行软件安装和配置
  config.vm.provision "shell", path: "./setup.sh"
end

setup.sh：

#!/bin/bash

# Copy hosts info
cat <<EOF > /etc/hosts
127.0.0.1	localhost
127.0.1.1	vagrant.vm	vagrant
192.168.56.11 kube-m1
192.168.56.12 kube-m2
192.168.56.13 kube-m3
192.168.56.14 kube-n1
192.168.56.15 kube-n2
192.168.56.16 kube-n3
# The following lines are desirable for IPv6 capable hosts
::1     localhost ip6-localhost ip6-loopback
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
EOF

# change time zone
cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
timedatectl set-timezone Asia/Shanghai
# set yum mirror
rm /etc/yum.repos.d/CentOS-Base.repo
cp /vagrant/yum/*.* /etc/yum.repos.d/
mv /etc/yum.repos.d/CentOS7-Base-163.repo /etc/yum.repos.d/CentOS-Base.repo
# install  kmod and ceph-common for rook
yum install -y wget curl conntrack-tools vim net-tools socat ntp kmod ceph-common
# install docker
groupadd docker
usermod -aG docker vagrant
rm -rf ~/.docker/
yum install -y docker.x86_64
cat > /etc/docker/daemon.json <<EOF
{
  "registry-mirrors" : ["https://k64bpq6l.mirror.aliyuncs.com"]
}
EOF

# Download kubelet and kubectl
KUBE_URL="https://storage.googleapis.com/kubernetes-release/release/v1.10.3/bin/linux/amd64"
wget "${KUBE_URL}/kubelet" -O /usr/local/bin/kubelet
chmod +x /usr/local/bin/kubelet

if [[ ${HOSTNAME} =~ m ]]; then
  wget "${KUBE_URL}/kubectl" -O /usr/local/bin/kubectl
  chmod +x /usr/local/bin/kubectl
fi

# Setup system vars
cat <<EOF > /etc/sysctl.d/k8s.conf
net.ipv4.ip_forward = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF

sysctl -p /etc/sysctl.d/k8s.conf

swapoff -a && sysctl -w vm.swappiness=0
sed '/vagrant--vg-swap_1/d' -i  /etc/fstab

CentOS7-Base-163.repo ：

[base]
name=CentOS-$releasever - Base - 163.com
#mirrorlist=http://mirrorlist.centos.org/?release=$releasever&arch=$basearch&repo=os
baseurl=http://mirrors.163.com/centos/$releasever/os/$basearch/
gpgcheck=1
gpgkey=http://mirrors.163.com/centos/RPM-GPG-KEY-CentOS-7

#released updates
[updates]
name=CentOS-$releasever - Updates - 163.com
#mirrorlist=http://mirrorlist.centos.org/?release=$releasever&arch=$basearch&repo=updates
baseurl=http://mirrors.163.com/centos/$releasever/updates/$basearch/
gpgcheck=1
gpgkey=http://mirrors.163.com/centos/RPM-GPG-KEY-CentOS-7

#additional packages that may be useful
[extras]
name=CentOS-$releasever - Extras - 163.com
#mirrorlist=http://mirrorlist.centos.org/?release=$releasever&arch=$basearch&repo=extras
baseurl=http://mirrors.163.com/centos/$releasever/extras/$basearch/
gpgcheck=1
gpgkey=http://mirrors.163.com/centos/RPM-GPG-KEY-CentOS-7

#additional packages that extend functionality of existing packages
[centosplus]
name=CentOS-$releasever - Plus - 163.com
baseurl=http://mirrors.163.com/centos/$releasever/centosplus/$basearch/
gpgcheck=1
enabled=0
gpgkey=http://mirrors.163.com/centos/RPM-GPG-KEY-CentOS-7

启动集群

$ # 下载 CentOS7 box 镜像
$ wget -c http://cloud.centos.org/centos/7/vagrant/x86_64/images/CentOS-7-x86_64-Vagrant-1801_02.VirtualBox.box
$ vagrant box add CentOS-7-x86_64-Vagrant-1801_02.VirtualBox.box --name centos/7
$ # 启动集群
$ vagrant up

节点信息

IP Address	Hostname
192.168.56.11	kube-m1
192.168.56.12	kube-m2
192.168.56.13	kube-m3
192.168.56.14	kube-n1
192.168.56.15	kube-n2
192.168.56.16	kube-n3

m 为 Master 节点，n 为 Node 节点。
主要操作将在 “kube-m1” 主机上进行，请事先配置好 m1 主机免密登录其他主机。
所有命名默认以 root 用户执行。
关闭所有节点的 SELinux
```
$ vim /etc/selinux/config
SELINUX=disabled
$ reboot
```
注意：如果不关闭 SELinux k8s 挂载目录会报 Permission denied 错误。

准备工作

一些需要初始化的东西已经写在 setup.sh 中，具体如下：

设置 /etc/hosts 解析到集群所有主机。
所有节点设置时区、软件源等设置。
所有节点安装 Docker 并设置加速器。
所有节点安装 kubectl。

备注

1. 由于资源限制，Etcd 部署在三台 k8s Master 节点上，宿主机资源充足的话可以部署在三台单独的主机上。

2. 免密登录只需要将宿主机公钥写入到 m1 主机的 ~/.ssh/authorized_keys 文件中，然后在 m1 主机执行 ssh-keygen 生成密钥对，并将公钥依次写入到其他需要登录主机的 ~/.ssh/authorized_keys 文件中。

示例:

# 宿主机执行
$ vagrant ssh kube-m2
# 进入 m2 主机后 su 到 root 用户，密码 vagrant
[vagrant@kube-n1 ~]$ su
Password:
# 将 m1 主机的公钥写入 m2 完成免密登录配置，依次配置其他主机
[root@kube-n1 vagrant]# mkdir ~/.ssh && echo "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDNEj6obDW/eERX04E22ucDGwUTQ6C8DSL1Dqun/7VuQJei6lzdWBBDKy6AJEPh/w51Po9vlqZCiso1+N/vwLzakSHqYh685L2tsXTpQza16N624sP7lt201TwUlKJ9tlQRzahtX833PCtvSSwv8T7EsZVwUN4zz7eA+To+hPzzVEBlU/wMgoHMWlGLG/dNGqUl3mJeBFJ7NRbC1ePzZYXUxhyFY9N36GcOoI+cJXroApecKMK5fSZbXyYDFRZ8Mf7EMkRQkXx5BasGRTAzKBkJ1OW2JBP17VdJqmJKOBHDnetwyH0zcS5C6/vWgiJspiJJu9Cw2I5/aZ6uij3g0tW9 root@kube-m1" >> ~/.ssh/authorized_keys

3. SELinux 需要手动关闭。

4. 关于镜像被墙的问题参考『虚拟机部署 Kubernetes v1.10.3 高可用集群 - 05 总结』中的描述。

Spring Boot Admin 集成自定义监控告警

Sat, 19 May 2018 14:41:00 GMT

Spring Boot Admin 是一个社区项目，可以用来监控和管理 Spring Boot 应用并且提供 UI，详细可以参考官方文档。

Spring Boot Admin 本身提供监控告警功能，但是默认只提供了 Hipchat、Slack 等国外流行的通讯软件的集成，虽然也有邮件通知，不过考虑到使用体检决定二次开发增加钉钉通知。

本文基于 Spring Boot Admin 目前最新版 1.5.7。

准备工作

Spring Boot Admin Server，参考文档 http://codecentric.github.io/spring-boot-admin/1.5.7/#getting-started
钉钉自定义机器人，参考文档 https://open-doc.dingtalk.com/docs/doc.htm?spm=a219a.7629140.0.0.64Ddtm&treeId=257&articleId=105735&docType=1

参考自带通知源码

由于官方文档上并没有增加自定义通知相关的文档，所以我们参考一下 Slack 通知源码 SlackNotifier.java。

源码比较长就不全部贴了，看一下关键部分：

public class SlackNotifier extends AbstractStatusChangeNotifier

protected void doNotify(ClientApplicationEvent event) throws Exception {
    this.restTemplate.postForEntity(this.webhookUrl, this.createMessage(event), Void.class);
}

可以看到流程还是比较简单的，继承 AbstractStatusChangeNotifier 类，实现了 doNotify 方法，当应用状态改变的时候会回调 doNotify 方法。

实现钉钉通知

DingTalkNotifier.java

public class DingTalkNotifier extends AbstractStatusChangeNotifier {
    private final SpelExpressionParser parser = new SpelExpressionParser();
    private RestTemplate restTemplate = new RestTemplate();
    private String webhookToken;
    private String atMobiles;
    private String msgtype = "markdown";
    private String title = "服务告警";
    private Expression message;

    public DingTalkNotifier() {
        this.message = this.parser.parseExpression("**#{application.name}** (#{application.id}) is **#{to.status}**", ParserContext.TEMPLATE_EXPRESSION);
    }

    @Override
    protected void doNotify(ClientApplicationEvent event) {
        this.restTemplate.postForEntity(this.webhookToken, this.createMessage(event), Void.class);
    }

    private HttpEntity<Map<String, Object>> createMessage(ClientApplicationEvent event) {
        Map<String, Object> messageJson = new HashMap<>();
        HashMap<String, String> params = new HashMap<>();
        params.put("text", this.getMessage(event));
        params.put("title", this.title);
        messageJson.put("dinggroup", this.dingGroup);
        messageJson.put("atMobiles", this.atMobiles);
        messageJson.put("msgtype", this.msgtype);
        messageJson.put(this.msgtype, params);
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON_UTF8);
        return new HttpEntity<>(messageJson, headers);
    }

    private String getAtMobilesString(String s) {
        StringBuilder atMobiles = new StringBuilder();
        String[] mobiles = s.split(",");
        for (String mobile : mobiles) {
            atMobiles.append("@").append(mobile);
        }
        return atMobiles.toString();
    }

    private String getMessage(ClientApplicationEvent event) {
        return this.atMobiles == null ? this.message.getValue(event, String.class) : this.message.getValue(event, String.class) + "\n >" + this.getAtMobilesString(this.atMobiles);
    }

    public void setRestTemplate(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public String getWebhookToken() {
        return webhookToken;
    }

    public void setWebhookToken(String webhookToken) {
        this.webhookToken = webhookToken;
    }

    public String getAtMobiles() {
        return atMobiles;
    }

    public void setAtMobiles(String atMobiles) {
        this.atMobiles = atMobiles;
    }

    public String getMsgtype() {
        return msgtype;
    }

    public void setMsgtype(String msgtype) {
        this.msgtype = msgtype;
    }

    public Expression getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = this.parser.parseExpression(message, ParserContext.TEMPLATE_EXPRESSION);
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }
}

代码逻辑也比较简单就不一一解释了。

增加钉钉通知自动配置

DingTalkNotifierConfiguration.java

@Configuration
@ConditionalOnProperty(
        prefix = "spring.boot.admin.notify.dingtalk",
        name = {"webhook-token"}
)
@AutoConfigureBefore({NotifierConfiguration.NotifierListenerConfiguration.class, NotifierConfiguration.CompositeNotifierConfiguration.class})
public class DingTalkNotifierConfiguration {
    public DingTalkNotifierConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean
    @ConfigurationProperties(prefix = "spring.boot.admin.notify.dingtalk")
    public DingTalkNotifier dingTalkNotifier() {
        return new DingTalkNotifier();
    }

}

大概解释下此配置类的主要作用：

当配置了 spring.boot.admin.notify.dingtalk.webhook-token 的时候此配置类生效。
将 spring.boot.admin.notify.dingtalk 下的配置注入到 DingTalkNotifier 生成的 Bean 中。
指定了此配置配生效的时间以及 Bean 生效的条件。

关键在于类和 Bean 上的几个注解，但这不是本文重点不展开说了。

增加相关配置

spring:
  boot:
    admin:
      notify:
        dingtalk:
          enabled: true
          webhook-token: https://oapi.dingtalk.com/robot/send?access_token=xxxxxxxxxx

然后当项目状态改变的时候就可以在钉钉收到消息了。