SRE运维博客

多云搭建 K3S 集群

Wenlong — Fri, 19 Nov 2021 11:32:53 +0800

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211119132529/
相关话题：https://www.cnsre.cn/tags/k3s/

双十一薅了几个云厂商的羊毛，一开始搭建了k3s的单机版，后面就想着能不能搭建一个k3s集群，然后参考了这位大佬的文章，就试着用 WireGuard 来进行组网。它轻量、便捷、高效，而且数据全程加密传输，是依托公网组建虚拟局域网的优秀选择。

环境介绍

服务器介绍

云厂商	公网IP地址	内网IP地址	虚拟网络IP地址	操作系统	内核版本
腾讯云1	42.xx.xx.12	10.0.16.8	192.168.1.1	CentOS Linux release 7.9.2009 (Core)	5.15.2-1
腾讯云2	122.xx.xxx.111	10.0.0.6	192.168.1.2	CentOS Linux release 7.9.2009 (Core)	5.15.2-1
阿里云	122.xx.xx.155	172.17.0.3	192.168.1.3	CentOS Linux release 7.9.2009 (Core)	5.15.2-1

搭建前准备

在搭建跨云的 k3s 集群前，我们需要把 WireGuard 安装好，WireGuard 对内核是有要求的，所以内核已经要升级到 5.15.2-1.el7.elrepo.x86_64

在所有节点开启 IP 地址转发

1
2
3

echo "net.ipv4.ip_forward = 1" >> /etc/sysctl.conf
echo "net.ipv4.conf.all.proxy_arp = 1" >> /etc/sysctl.conf
sysctl -p /etc/sysctl.conf

所有节点开启修改主机名称

# 腾讯云1执行
hostnamectl  set-hostname k3s-master
# 腾讯云2执行
hostnamectl  set-hostname k3s-node1
# 阿里云执行
hostnamectl  set-hostname k3s-node2

升级内核

几个服务器默认的内核都是 3.10 的，安装WireGuard 需要吧内核升级到比较高的版本。

升级内核前

先升级软件包（非必要）

`1`	`yum update -y`

添加 iptables 规则，允许本机的 NAT 转换：

所有节点都要执行

iptables -A INPUT -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
iptables -A FORWARD -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i wg0 -o wg0 -m conntrack --ctstate NEW -j ACCEPT
iptables -t nat -A POSTROUTING -s 192.168.1.1/24 -o eth0 -j MASQUERADE

wg0:为你定义的虚拟网卡

192.168.1.1: 为你的虚拟IP地址段

eth0:为你的物理网卡

升级内核

所有节点都要执行

方法1：

直接下载RPM包进行安装。

如果你想安装其他内核，你也可以在这里下载

1
2

wget https://pan.cnsre.cn/d/Package/Linux/kernel/kernel-ml-5.15.2-1.el7.elrepo.x86_64.rpm
rpm -ivh kernel-ml-5.15.2-1.el7.elrepo.x86_64.rpm

方法 2：

利用包管理工具更新

# 载入公钥
rpm --import https://www.elrepo.org/RPM-GPG-KEY-elrepo.org
# 升级安装 elrepo
rpm -Uvh http://www.elrepo.org/elrepo-release-7.0-5.el7.elrepo.noarch.rpm
# 载入 elrepo-kernel 元数据
yum --disablerepo=\* --enablerepo=elrepo-kernel repolist
# 安装最新版本的内核
yum --disablerepo=\* --enablerepo=elrepo-kernel install  kernel-ml.x86_64  -y
# 删除旧版本工具包
yum remove kernel-tools-libs.x86_64 kernel-tools.x86_64  -y

方法3：

通过源码包编译安装.

这种方式可定制性强，但也比较复杂，有需要的可自行查找资料安装，下面只给出各系统版本内核源码包的下载地址

修改默认内核版本

# 查看当前实际启动顺序
grub2-editenv list
# 查看内核插入顺序
grep "^menuentry" /boot/grub2/grub.cfg | cut -d "'" -f2
# 设置默认启动
grub2-set-default 'CentOS Linux (5.15.2-1.el7.elrepo.x86_64) 7 (Core)'
# 重新创建内核配置
grub2-mkconfig -o /boot/grub2/grub.cfg
# 重启服务器
reboot
# 验证当前内核版本
uname -r

内核版本一定要是比较高的，不然启动WireGuard会有如下报错。

[#] ip link add wg0 type wireguard
RTNETLINK answers: Operation not supported
Unable to access interface: Protocol not supported
[#] ip link delete dev wg0
Cannot find device "wg0"

安装 WireGuard

所有节点执行

安装流程非常简单，我这里是直接将 CentOS 内核更新到目前最新的 5.15.2 版本，其中就已经包含了 WireGuard 的内核模块，只需要安装 wireguard-tools 这个 yum 包就行了。

1
2

yum install epel-release https://www.elrepo.org/elrepo-release-7.el7.elrepo.noarch.rpm
yum install yum-plugin-elrepo kmod-wireguard wireguard-tools -y

配置 WireGuard

wireguard-tools 包提供了我们所需的工具 wg 和 wg-quick，可以使用它们来分别完成手动部署和自动部署。

先按照官方文档描述的形式，生成腾讯云1用于加密解密的密钥

`1`	`wg genkey \| tee privatekey \| wg pubkey > publickey`

然后在当前目录下就生成了 privatekey 和 publickey 两个文件

密钥是配置到本机的，而公钥是配置到其它机器里的。

1
2
3

cat privatekey publickey
EMWcI01iqM4zkb7xfbaaxxxxxxxxDo2GJUA=
0ay8WfGOIHndWklSIVBqrsp5LDWxxxxxxxxxxxxxxQ=

现在我们需要与上述主机对等联网的 腾讯云2 阿里云 ，其公网IP（这边需要填写的是能与主机通信的IP）是 122.xx.xxx.111，122.xx.xx.155

我们首先依照上面的流程安装 WireGuard 并生成好 腾讯云2 阿里云 的密钥。

然后编写 腾讯云1 完整的配置文件，以供 wg-quick 使用，在主机A的 /etc/wireguard/wg0.conf 中写入

[Interface]
PrivateKey = EMWcI01iqM4zkb7xfbaaxxxxxxxxDo2GJUA=
Address = 192.168.1.1
ListenPort = 5418

[Peer]
PublicKey = 腾讯云2 publickey
EndPoint = 122.xx.xxx.111:5418
AllowedIPs = 192.168.1.2/32

[Peer]
PublicKey = 阿里云publickey
EndPoint = 122.xx.xx.155:5418
AllowedIPs = 192.168.1.3/32

配置说明

Interface: 小节是属于腾讯云1（也就是本机）的配置.

Address: 是分配给 腾讯云1 虚拟IP，

ListenPort: 是主机之间通讯使用的端口，是 UDP 协议的。

Peer: 是属于需要通信的 腾讯云2 、阿里云 的信息，有多少需要通信的主机，就添加多少个 Peer 小节。

EndPoint: 是 腾讯云2 、阿里云的公网IP与 WireGuard 监听的 UDP 端口，这个 IP 不一定是公网，

如果你的机器通过内网也能通信，直接用内网 IP 也可以，当然要注意这个IP需要所有加入局域网的主机都能通信才行。

AllowedIPs: 是指本机发起连接的哪些IP应该将流量转发到这个节点去，比如我们给主机B分配了内网IP 192.168.1.2，那么在主机A上发送到 192.168.1.2 的数据包，都应该转发到这个 EndPoint 上，它其实起的是一个过滤作用。而且多个 Peer 时，这里配置的IP地址不能有冲突。

各个节点生产的 privatekey 和publickey 分别如下

# master 节点
[root@k3s-master ~]# cat privatekey publickey
EMWcI01iqM4zkb7xfbaaxxxxxxxxDo2GJUA=
0ay8WfGOIHndWklSIVBqrsp5LDWxxxxxxxxxxxxxxQ=
# node1 节点
[root@k3s-node1 ~]# cat privatekey publickey
QGdNkzpnIkuvUU+00C6XYxxxxxxxxxK0D82qJVc=
3izpVbZgPhlM+S5szOogTDTxxxxxxxxxuKuDGn4=
# node2 节点
[root@k3s-node2 ~]# cat privatekey publickey
WOOObkWINkW/hqaAME9r+xxxxxxxxxm+r2Q=
0f0dn60+tBUfYgzw7rIihKbqxxxxxxxxa6Wo=

各节点配置

# master 节点
cat /etc/wireguard/wg0.conf
[Interface]
PrivateKey = EMWcI01iqM4zkb7xfbaaxxxxxxxxDo2GJUA=
Address = 192.168.1.1
ListenPort = 5418

[Peer]
PublicKey = 3izpVbZgPhlM+S5szOogTDTxxxxxxxxxuKuDGn4=
EndPoint = 122.xx.xxx.111:5418
AllowedIPs = 192.168.1.2/32

[Peer]
PublicKey = 0f0dn60+tBUfYgzw7rIihKbqxxxxxxxxa6Wo=
EndPoint = 122.xx.xx.155:5418
AllowedIPs = 192.168.1.3/32

# node1 节点
cat /etc/wireguard/wg0.conf
[Interface]
PrivateKey = QGdNkzpnIkuvUU+00C6XYxxxxxxxxxK0D82qJVc=
Address = 192.168.1.2
ListenPort = 5418

[Peer]
PublicKey = 0ay8WfGOIHndWklSIVBqrsp5LDWxxxxxxxxxxxxxxQ=
EndPoint = 42.xxx.xx.16:5418
AllowedIPs = 192.168.1.1/32

[Peer]
PublicKey = 0f0dn60+tBUfYgzw7rIihKbqxxxxxxxxa6Wo=
EndPoint = 122.xx.xx.155:5418
AllowedIPs = 192.168.1.3/32

# node2 节点
cat /etc/wireguard/wg0.conf
[Interface]
PrivateKey = WOOObkWINkW/hqaAME9r+xxxxxxxxxm+r2Q=
Address = 192.168.1.3
ListenPort = 5418

[Peer]
PublicKey = 0ay8WfGOIHndWklSIVBqrsp5LDWxxxxxxxxxxxxxxQ=
EndPoint = 42.xxx.xx.16:5418
AllowedIPs = 192.168.1.1/32

[Peer]
PublicKey = 3izpVbZgPhlM+S5szOogTDTxxxxxxxxxuKuDGn4=
EndPoint = 122.xx.xx.155:5418
AllowedIPs = 192.168.1.2/32

启动 WireGuard

配置文件写好后，使用 wg-quick 工具来创建虚拟网卡，

`1`	`wg-quick up wg0`

上面命令中的 wg0 对应的是 /etc/wireguard/wg0.conf 这个配置文件，其自动创建的网卡设备，名字就是 wg0，这对应关系自不必多言。

将腾讯云2 、阿里云 的网卡设备都安装配置好后，就能使用 wg 命令来观察组网情况了

[root@k3s-master ~]# wg
interface: wg0
  public key: 0ay8WfGOIHndWklSIVBqrsp5LDWxxxxxxxxxxxxxxQ=
  private key: (hidden)
  listening port: 5418

peer: 0f0dn60+tBUfYgzw7rIihKbqxxxxxxxxa6Wo=
  endpoint: 122.xx.xx.155:5418
  allowed ips: 192.168.1.3/32
  latest handshake: 3 minutes, 3 seconds ago
  transfer: 35.40 KiB received, 47.46 KiB sent

peer: 3izpVbZgPhlM+S5szOogTDTxxxxxxxxxuKuDGn4=
  endpoint: 122.xx.xxx.111:5418
  allowed ips: 192.168.1.2/32
  latest handshake: 5 minutes, 6 seconds ago
  transfer: 24.84 KiB received, 35.21 KiB sent

可以看到列出了对等联网的节点信息，还有通信测量数据。然后可以通过 ping 其他主机的虚拟IP或者 ssh 其他主机的IP地址，来检查网络通信是否正常。

自动化

系统重启后，WireGuard 创建的网卡设备就会丢失，有自动化的脚本

`1`	`systemctl enable wg-quick@wg0`

使用上述命令生成systemd守护脚本，开机会自动运行up指令。

配置热重载

wg-quick并未提供重载相关的指令，但是提供了 strip 指令，可以将 conf 文件转换为 wg 指令可以识别的格式。

`1`	`wg syncconf wg0 <(wg-quick strip wg0)`

即可实现热重载。

完成 WireGuard 的安装配置以后，我们就可以接下来安装 k3s 的集群了。

安装 K3S 集群

master节点安装

curl -sfL http://rancher-mirror.cnrancher.com/k3s/k3s-install.sh | INSTALL_K3S_MIRROR=cn sh  -s -  --node-external-ip 42.xx.xx.12--advertise-address 42.xx.xx.12--node-ip 192.168.1.1 --flannel-iface wg0

参数说明：

--node-external-ip 42.xxx.xx.16 为节点设置外部IP，阿里云VPC的外网IP并未直接绑定到虚拟机网卡上，所以我要设置这个参数，避免k3s组件在设置loadbalance时，将内网IP当作公网IP使用。
--advertise-address 42.xxx.xx.16 用于设置kubectl工具以及子节点进行通讯使用的地址，可以是IP，也可以是域名，在创建apiserver证书时会将此设置到有效域中。
--node-ip 10.20.30.1 如果不设置这个参数，那么第一张网卡设备上的IP就会被选中，所以这个IP常是内网IP。但我自行组建了虚拟局域网，所以需要指定虚拟局域网的IP（也就是WireGuard的IP）。
--flannel-iface wg0 wg0是WireGuard创建的网卡设备，我需要使用虚拟局域网来进行节点间的通信，所以这里需要指定为wg0。

另外就是，由于WireGuard的所有流量都是加密传输的，通过它来进行节点间的通信，就已经能够保证通信安全，也就没有必要改用其它的CNI驱动，使用默认的就可以了。

在主节点执行上述命令后，一分钟不到就可以看到脚本提示安装完成。通过命令查看下主控端的运行情况

`1`	`systemctl status k3s`

如果运行正常，那么就看看容器的运行状态是否正常

`1`	`kubectl get pods -A`

-A 参数用于查看所有命名空间，如果容器都处于 running 状态，那么安装就成功了，接下来要可以添加被控节点。

Agent 安装

有了上述安装主控的经验，安装work节点更加简单，参数需要一定的调整

腾讯云2执行

curl -sfL http://rancher-mirror.cnrancher.com/k3s/k3s-install.sh | INSTALL_K3S_MIRROR=cn K3S_URL=https://192.168.1.1:6443 K3S_TOKEN=K107xxxxxxxxxxxxxxxx2cf95048d6a3cd85f15717edfbe5::server:xxxxxxxxxxxxxxxxxxxx4da1b7e701f67e sh -s - --node-external-ip 122.xx.xxx.111 --node-ip 192.168.1.2 --flannel-iface wg0

阿里云执行

curl -sfL http://rancher-mirror.cnrancher.com/k3s/k3s-install.sh | INSTALL_K3S_MIRROR=cn K3S_URL=https://192.168.1.1:6443 K3S_TOKEN=K10720eda8a278bdc7b9b6d787c9676a92119bb2cf95048d6a3cd85f15717edfbe5::server:e98b986e8202885cb54da1b7e701f67e sh -s - --node-external-ip 122.xx.xx.155 --node-ip 192.168.1.3 --flannel-iface wg0

参数不必过多解释

K3S_Token 去 cat /var/lib/rancher/k3s/server/node-token 获取即可。
K3S_URL 需要设置master的通信地址端口，端口默认是6443，IP地址就是虚拟网域的IP，这样流量就会通过WireGuard加密传输。
node-external-ip 为节点公网地址
node-ip 节点虚拟IP地址
执行完稍等一会，安装成功后，查看服务运行状态。

`1`	`systemctl status k3s-agent`

如果有报错就根据报错查找解决方案。

都安装好以后在master节点检查。

`1`	`kubectl get nodes -o wide`

至此多云 K3S 集群已经搭建完毕。

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211119132529/
相关话题：https://www.cnsre.cn/tags/k3s/

Clawdbot 完全指南：打造您的个人 AI 助手

Wenlong — Tue, 27 Jan 2026 11:53:47 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/260127115347/
相关话题：https://www.cnsre.cn/tags/ai/
版权声明: 如需转载，请联系作者授权

引言

在人工智能快速发展的今天，拥有一个个人 AI 助手已经不再是遥不可及的梦想。Clawdbot 作为一款开源的自托管 AI 助手，正在改变我们与 AI 交互的方式。根据官方文档，Clawdbot 支持超过 50 种平台集成，包括 WhatsApp、Telegram、Discord 等主流消息应用。

本文将深入探讨 Clawdbot 的核心功能、安装配置方法以及如何将其集成到您的日常工作流程中。

1. 什么是 Clawdbot？

Clawdbot 是一个开源的个人 AI 助手，它运行在您自己的硬件上，通过消息应用与您进行交互。与云端 AI 助手不同，Clawdbot 完全由您控制，具有持久记忆、浏览器控制和多代理支持等功能。

1.1 核心特性

根据官方文档，Clawdbot 的主要特性包括：

🤖 多平台支持：WhatsApp、Telegram、Discord、Slack、Signal、iMessage 等 50+ 平台
🧠 持久记忆：记住对话历史和用户偏好
🔧 技能平台：可扩展的技能系统
🌐 浏览器控制：自动执行网页操作
🏠 自托管：完全控制您的数据和隐私
⚡ 多代理支持：支持多个 AI 模型协作

1.2 架构概览

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   消息平台      │    │   Clawdbot      │    │   AI 模型       │
│                 │◄──►│   网关          │◄──►│                 │
│ WhatsApp        │    │                 │    │ Claude          │
│ Telegram        │    │ 代理系统        │    │ GPT-4           │
│ Discord         │    │ 技能系统        │    │ Gemini          │
│ ...             │    │ 记忆系统        │    │ ...             │
└─────────────────┘    └─────────────────┘    └─────────────────┘

2. 安装指南

2.1 系统要求

根据官方文档，安装 Clawdbot 需要以下环境：

操作系统：macOS 14+, Ubuntu 20.04+, Windows 10+ (WSL2)
Node.js：v18.0.0 或更高版本
内存：至少 2GB RAM
存储：至少 1GB 可用空间
网络：稳定的互联网连接

2.2 快速安装方法

方法 1：使用安装脚本（推荐）

# 文件路径: 终端命令
# 来源: https://docs.clawd.bot/install/
# 版本: v1.0.0+

# macOS/Linux 安装
curl -fsSL https://clawd.bot/install.sh | bash

# Windows 安装 (PowerShell)
iwr -useb https://clawd.bot/install.ps1 | iex

验证安装:

`1`	`clawdbot --version`

预期输出:

clawdbot v1.2.3

方法 2：使用 npm 安装

# 文件路径: 终端命令
# 来源: https://docs.clawd.bot/install/
# 版本: v1.0.0+

# 全局安装
npm install -g clawdbot@latest

# 或者使用 pnpm
pnpm add -g clawdbot@latest

# 验证安装
which clawdbot

2.3 macOS 原生应用安装

Clawdbot 提供了专门的 macOS 应用程序：

# 文件路径: 终端命令
# 来源: https://toclawdbot.com/macos
# 版本: v1.0.0+

# 使用 Homebrew 安装
brew install clawdbot/tap/clawdbot

# 或者下载 DMG 文件
# 从 https://clawd.bot 下载最新版 macOS DMG
# 拖拽 Clawdbot.app 到 Applications 文件夹

2.4 Docker 安装

# 文件路径: docker-compose.yml
# 来源: https://docs.clawd.bot/install/docker
# 版本: v1.0.0+

version: '3.8'
services:
  clawdbot:
    image: clawdbot/clawdbot:latest
    container_name: clawdbot
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - CLAWD_CONFIG_PATH=/app/config
    volumes:
      - ./config:/app/config
      - ./data:/app/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

启动容器:

`1`	`docker-compose up -d`

3. 配置和初始化

3.1 运行设置向导

Clawdbot 提供了交互式设置向导：

# 文件路径: 终端命令
# 来源: https://docs.clawd.bot/wizard
# 版本: v1.0.0+

# 启动设置向导（初始化配置）
clawdbot setup

# 运行交互式设置向导
clawdbot onboard

# 配置凭据和设备
clawdbot configure

向导步骤：

系统检查：验证系统兼容性和依赖
模型配置：选择 AI 模型和提供商
消息平台：选择要集成的消息应用
安全配置：设置访问权限和加密
初始化：创建配置文件和数据目录

3.2 手动配置

创建配置文件：

// 文件路径: ~/.config/clawdbot/config.json
// 来源: https://github.com/clawdbot/clawdbot/blob/main/docs/configuration.md
// 版本: v1.0.0+

{
  "server": {
    "port": 3000,
    "host": "localhost",
    "protocol": "http"
  },
  "ai": {
    "provider": "anthropic",
    "model": "claude-3-5-sonnet-20241022",
    "apiKey": "YOUR_ANTHROPIC_API_KEY",
    "maxTokens": 4096,
    "temperature": 0.7
  },
  "memory": {
    "enabled": true,
    "storage": "file",
    "path": "./data/memory.json",
    "maxEntries": 1000
  },
  "channels": {
    "whatsapp": {
      "enabled": true,
      "sessionPath": "./sessions/whatsapp"
    },
    "telegram": {
      "enabled": true,
      "botToken": "YOUR_TELEGRAM_BOT_TOKEN"
    },
    "discord": {
      "enabled": true,
      "botToken": "YOUR_DISCORD_BOT_TOKEN"
    }
  },
  "skills": {
    "enabled": true,
    "directory": "./skills",
    "autoLoad": true
  }
}

3.3 开发环境配置

对于开发环境，Clawdbot 提供了隔离模式：

# 文件路径: 终端命令
# 来源: clawdbot --help
# 版本: v2026.1.24-3

# 开发模式（隔离状态，使用端口 19001）
clawdbot --dev gateway

# 使用命名配置文件
clawdbot --profile testing setup

# 禁用颜色输出（用于脚本）
clawdbot --no-color status

开发模式特点：

隔离的配置和状态文件（~/.clawdbot-dev/）
默认网关端口改为 19001
不会干扰生产环境配置

3.5 环境变量配置

# 文件路径: ~/.config/clawdbot/.env
# 来源: https://github.com/clawdbot/clawdbot/blob/main/docs/configuration.md
# 版本: v1.0.0+

# AI 模型配置
ANTHROPIC_API_KEY=your_anthropic_key_here
OPENAI_API_KEY=your_openai_key_here
GOOGLE_API_KEY=your_google_key_here

# 数据库配置
DATABASE_URL=file:./data/clawdbot.db
REDIS_URL=redis://localhost:6379

# 安全配置
JWT_SECRET=your_jwt_secret_here
ENCRYPTION_KEY=your_encryption_key_here

# 消息平台配置
TELEGRAM_BOT_TOKEN=your_telegram_token
DISCORD_BOT_TOKEN=your_discord_token
WHATSAPP_SESSION_PATH=./sessions/whatsapp

4. 消息平台集成

4.1 WhatsApp 集成

使用 QR 码配对

# 文件路径: 终端命令
# 来源: https://docs.clawd.bot/start/pairing
# 版本: v1.0.0+

# 启动 WhatsApp 配对模式
clawdbot pair whatsapp

# 或者使用完整命令
clawdbot channels add whatsapp --method=qr

验证步骤：

在手机上打开 WhatsApp
扫描终端显示的 QR 码
等待连接确认

配置示例

// 文件路径: ~/.config/clawdbot/channels/whatsapp.json
// 来源: https://clawd.bot/integrations
// 版本: v1.0.0+

{
  "platform": "whatsapp",
  "enabled": true,
  "config": {
    "sessionId": "my-whatsapp-session",
    "qrMaxRetries": 3,
    "authTimeoutMs": 60000,
    "keepAliveIntervalMs": 30000,
    "markOnlineOnConnect": true,
    "fireInitQueries": true
  },
  "features": {
    "readReceipts": true,
    "typingIndicator": true,
    "autoReply": true,
    "groupMessages": true
  }
}

4.2 Telegram 集成

创建 Bot

# 文件路径: 终端命令
# 来源: https://docs.clawd.bot/start/pairing
# 版本: v1.0.0+

# 1. 在 Telegram 中搜索 @BotFather
# 2. 发送 /newbot 命令
# 3. 获取 Bot Token
# 4. 配置 Clawdbot
clawdbot channels add telegram --token=YOUR_BOT_TOKEN

Telegram 配置

// 文件路径: ~/.config/clawdbot/channels/telegram.json
// 来源: https://clawd.bot/integrations
// 版本: v1.0.0+

{
  "platform": "telegram",
  "enabled": true,
  "token": "YOUR_TELEGRAM_BOT_TOKEN",
  "webhook": {
    "enabled": true,
    "port": 8443,
    "host": "your-domain.com"
  },
  "features": {
    "inlineQueries": true,
    "commands": true,
    "inlineKeyboard": true,
    "groupMessages": true
  },
  "commands": [
    {
      "command": "start",
      "description": "Start the bot"
    },
    {
      "command": "help",
      "description": "Show help information"
    },
    {
      "command": "status",
      "description": "Check bot status"
    }
  ]
}

4.3 Discord 集成

创建 Discord 应用

# 文件路径: 终端命令
# 来源: https://docs.clawd.bot/start/pairing
# 版本: v1.0.0+

# 1. 访问 https://discord.com/developers/applications
# 2. 创建新应用
# 3. 获取 Bot Token
# 4. 配置权限
clawdbot channels add discord --token=YOUR_DISCORD_BOT_TOKEN

Discord 配置

// 文件路径: ~/.config/clawdbot/channels/discord.json
// 来源: https://clawd.bot/integrations
// 版本: v1.0.0+

{
  "platform": "discord",
  "enabled": true,
  "token": "YOUR_DISCORD_BOT_TOKEN",
  "intents": [
    "GUILDS",
    "GUILD_MESSAGES",
    "DIRECT_MESSAGES",
    "MESSAGE_CONTENT"
  ],
  "prefix": "!",
  "features": {
    "slashCommands": true,
    "embeds": true,
    "reactions": true,
    "voiceChannels": false
  },
  "allowedChannels": ["general", "ai-chat"],
  "allowedRoles": ["@everyone", "AI Users"]
}

5. CLI 命令参考

5.1 核心命令

根据官方 CLI 帮助，Clawdbot 提供以下核心命令：

# 文件路径: 终端命令
# 来源: clawdbot --help (官方 CLI 输出)
# 版本: v2026.1.24-3

# 初始化配置
clawdbot setup

# 交互式设置向导
clawdbot onboard

# 配置凭据和设备
clawdbot configure

# 健康检查和修复
clawdbot doctor

# 打开控制面板
clawdbot dashboard

验证命令:

`1`	`clawdbot --version`

预期输出:

🦞 Clawdbot 2026.1.24-3 (885167d) — No $999 stand required.

5.2 网关控制

# 启动网关服务
clawdbot gateway

# 开发模式启动（隔离状态）
clawdbot --dev gateway

# 指定端口启动
clawdbot gateway --port 18789

# 强制启动（杀掉占用端口的进程）
clawdbot gateway --force

# 检查网关健康状态
clawdbot health

# 查看网关日志
clawdbot logs

验证网关状态:

`1`	`clawdbot health`

预期输出:

✅ Gateway is healthy
🌐 WebSocket: ws://127.0.0.1:18789
📊 Uptime: 2h 15m

5.3 消息平台管理

# 连接消息平台（交互式）
clawdbot channels login --verbose

# 添加 WhatsApp（二维码方式）
clawdbot channels add whatsapp --method=qr

# 添加 Telegram 机器人
clawdbot channels add telegram --token=YOUR_BOT_TOKEN

# 添加 Discord 机器人
clawdbot channels add discord --token=YOUR_DISCORD_BOT_TOKEN

# 查看通道状态
clawdbot status

验证平台连接:

`1`	`clawdbot status`

预期输出:

📱 Channel Status:
✅ WhatsApp: Connected (Web)
✅ Telegram: Connected (@your_bot)
⏸️  Discord: Disconnected

5.4 代理和技能管理

# 运行代理对话
clawdbot agent --to +1234567890 --message "Hello" --deliver

# 管理多个代理
clawdbot agents list
clawdbot agents create --name "assistant"
clawdbot agents switch --name "assistant"

# 技能管理
clawdbot skills list
clawdbot skills install <skill-name>
clawdbot skills remove <skill-name>

# 记忆搜索
clawdbot memory search "project discussion"
clawdbot memory cleanup

5.5 消息发送

# 发送 WhatsApp 消息
clawdbot message send --target +1234567890 --message "Hi there!"

# 发送 Telegram 消息
clawdbot message send --channel telegram --target @username --message "Hello"

# 发送 Discord 消息
clawdbot message send --channel discord --target channel-id --message "Test message"

# JSON 格式输出
clawdbot message send --target +1234567890 --message "Hi" --json

5.6 高级功能

# 浏览器管理
clawdbot browser start
clawdbot browser stop
clawdbot browser screenshot

# 定时任务
clawdbot cron list
clawdbot cron add --schedule "0 9 * * *" --command "morning-briefing"

# 模型配置
clawdbot models list
clawdbot models set --provider anthropic --model claude-3-5-sonnet

# 系统信息
clawdbot system info
clawdbot system events

5.7 开发选项

# 开发模式（隔离状态，端口 19001）
clawdbot --dev gateway

# 使用命名配置文件
clawdbot --profile work setup
clawdbot --profile personal gateway

# 禁用颜色输出
clawdbot --no-color status

开发模式验证:

1
2

# 检查开发网关
clawdbot --dev health

预期输出:

🔧 Development Mode Active
🌐 Dev Gateway: ws://127.0.0.1:19001
📁 Isolated State: ~/.clawdbot-dev/

6. 基本使用演示

5.1 启动 Clawdbot

# 文件路径: 终端命令
# 来源: https://docs.clawd.bot/cli/
# 版本: v1.0.0+

# 启动 Clawdbot 网关服务
clawdbot gateway

# 开发模式启动（推荐用于测试）
clawdbot --dev gateway

# 检查服务健康状态
clawdbot health

预期输出:

✅ Gateway is healthy
🌐 WebSocket: ws://127.0.0.1:18789
📱 Connected channels: WhatsApp, Telegram
🤖 Active models: Claude 3.5 Sonnet
📊 Uptime: 15m 32s

5.2 发送消息测试

# 文件路径: 终端命令
# 来源: https://docs.clawd.bot/cli/message
# 版本: v1.0.0+

# 发送测试消息到 WhatsApp
clawdbot message whatsapp --to="+1234567890" --text="Hello from Clawdbot!"

# 发送消息到 Telegram
clawdbot message telegram --to="@username" --text="Hello from Clawdbot!"

# 发送消息到 Discord
clawdbot message discord --to="channel-id" --text="Hello from Clawdbot!"

5.3 浏览器控制演示

// 文件路径: skills/browser-automation.js
// 来源: https://github.com/clawdbot/clawdbot/blob/main/AGENTS.md
// 版本: v1.0.0+

const { Skill } = require('clawdbot-sdk');

class BrowserAutomation extends Skill {
  constructor() {
    super({
      name: 'browser-automation',
      description: 'Automate browser tasks',
      version: '1.0.0'
    });
  }

  async execute(context, args) {
    const { action, url, selector, text } = args;
    
    switch (action) {
      case 'navigate':
        await this.browser.goto(url);
        return { success: true, message: `Navigated to ${url}` };
        
      case 'click':
        await this.browser.click(selector);
        return { success: true, message: `Clicked ${selector}` };
        
      case 'type':
        await this.browser.type(selector, text);
        return { success: true, message: `Typed into ${selector}` };
        
      case 'screenshot':
        const screenshot = await this.browser.screenshot();
        return { success: true, screenshot };
        
      default:
        return { success: false, error: 'Unknown action' };
    }
  }
}

module.exports = BrowserAutomation;

7. 高级配置

6.1 多模型配置

// 文件路径: ~/.config/clawdbot/models.json
// 来源: https://github.com/clawdbot/clawdbot/blob/main/docs/configuration.md
// 版本: v1.0.0+

{
  "models": {
    "primary": {
      "provider": "anthropic",
      "model": "claude-3-5-sonnet-20241022",
      "apiKey": "${ANTHROPIC_API_KEY}",
      "maxTokens": 4096,
      "temperature": 0.7
    },
    "fallback": {
      "provider": "openai",
      "model": "gpt-4",
      "apiKey": "${OPENAI_API_KEY}",
      "maxTokens": 4096,
      "temperature": 0.5
    },
    "fast": {
      "provider": "anthropic",
      "model": "claude-3-haiku-20240307",
      "apiKey": "${ANTHROPIC_API_KEY}",
      "maxTokens": 2048,
      "temperature": 0.3
    }
  },
  "routing": {
    "default": "primary",
    "fallback": "fallback",
    "quick": "fast"
  }
}

6.2 技能系统配置

// 文件路径: ~/.config/clawdbot/skills.json
// 来源: https://github.com/clawdbot/clawdbot/blob/main/AGENTS.md
// 版本: v1.0.0+

{
  "skills": {
    "enabled": true,
    "autoLoad": true,
    "directory": "./skills",
    "permissions": {
      "fileSystem": "ask",
      "network": "allow",
      "browser": "allow",
      "system": "deny"
    },
    "installed": [
      {
        "name": "calendar",
        "enabled": true,
        "config": {
          "provider": "google",
          "syncInterval": 300
        }
      },
      {
        "name": "email",
        "enabled": true,
        "config": {
          "provider": "gmail",
          "checkInterval": 60
        }
      },
      {
        "name": "reminder",
        "enabled": true,
        "config": {
          "storage": "memory",
          "timezone": "UTC"
        }
      }
    ]
  }
}

6.3 内存和持久化配置

// 文件路径: ~/.config/clawdbot/memory.json
// 来源: https://github.com/clawdbot/clawdbot/blob/main/docs/configuration.md
// 版本: v1.0.0+

{
  "memory": {
    "enabled": true,
    "provider": "sqlite",
    "config": {
      "database": "./data/memory.db",
      "table": "conversations",
      "maxEntries": 10000,
      "retentionDays": 30
    },
    "embedding": {
      "provider": "openai",
      "model": "text-embedding-3-small",
      "dimensions": 1536
    },
    "search": {
      "enabled": true,
      "threshold": 0.7,
      "maxResults": 5
    }
  }
}

8. 故障排除

7.1 诊断工具

# 文件路径: 终端命令
# 来源: https://docs.clawd.bot/cli/doctor
# 版本: v1.0.0+

# 运行健康检查
clawdbot doctor

# 查看系统状态
clawdbot system

# 检查日志
clawdbot logs

# 重启服务
clawdbot restart

7.2 常见问题解决

# 文件路径: 故障排除脚本
# 来源: https://docs.clawd.bot/troubleshooting
# 版本: v1.0.0+

#!/bin/bash
# Clawdbot 故障排除脚本

echo "🔍 Clawdbot 诊断检查"
echo "========================"

# 检查 Node.js 版本
node_version=$(node --version)
echo "Node.js 版本: $node_version"

# 检查 Clawdbot 安装
if command -v clawdbot &> /dev/null; then
    echo "✅ Clawdbot 已安装"
    clawdbot --version
else
    echo "❌ Clawdbot 未安装"
fi

# 检查端口占用
if netstat -tuln | grep -q ":3000"; then
    echo "✅ 端口 3000 正在使用"
else
    echo "⚠️ 端口 3000 未使用"
fi

# 检查配置文件
if [ -f ~/.config/clawdbot/config.json ]; then
    echo "✅ 配置文件存在"
else
    echo "❌ 配置文件不存在"
fi

# 检查数据目录
if [ -d ~/.local/share/clawdbot ]; then
    echo "✅ 数据目录存在"
else
    echo "⚠️ 数据目录不存在"
fi

echo "诊断完成！"

9. 最佳实践和技巧

8.1 安全配置

// 文件路径: ~/.config/clawdbot/security.json
// 来源: 安全配置最佳实践
// 版本: v1.0.0+

{
  "security": {
    "encryption": {
      "enabled": true,
      "algorithm": "aes-256-gcm",
      "keyRotation": 86400
    },
    "authentication": {
      "jwt": {
        "secret": "${JWT_SECRET}",
        "expiresIn": "24h"
      },
      "apiKey": {
        "enabled": true,
        "rateLimit": 100
      }
    },
    "permissions": {
      "adminUsers": ["admin@example.com"],
      "allowedIPs": ["127.0.0.1", "::1"],
      "blockedCommands": ["rm -rf", "sudo", "su"]
    }
  }
}

8.2 性能优化

# 文件路径: 性能优化脚本
# 来源: 性能优化最佳实践
# 版本: v1.0.0+

#!/bin/bash
# Clawdbot 性能优化

echo "🚀 Clawdbot 性能优化"
echo "====================="

# 清理内存
clawdbot memory cleanup

# 优化数据库
clawdbot db optimize

# 清理日志
clawdbot logs clean --keep-days=7

# 重启服务以释放资源
clawdbot restart

echo "优化完成！"

8.3 监控和告警

// 文件路径: skills/monitoring.js
// 来源: 监控最佳实践
// 版本: v1.0.0+

const { Skill } = require('clawdbot-sdk');

class MonitoringSkill extends Skill {
  constructor() {
    super({
      name: 'monitoring',
      description: 'System monitoring and alerting',
      version: '1.0.0'
    });
  }

  async execute(context, args) {
    const { action } = args;
    
    switch (action) {
      case 'status':
        return await this.getSystemStatus();
      case 'health':
        return await this.checkHealth();
      case 'metrics':
        return await this.getMetrics();
      default:
        return { error: 'Unknown action' };
    }
  }

  async getSystemStatus() {
    const status = {
      uptime: process.uptime(),
      memory: process.memoryUsage(),
      cpu: process.cpuUsage(),
      timestamp: new Date().toISOString()
    };
    
    return { success: true, status };
  }

  async checkHealth() {
    const health = {
      gateway: await this.checkGateway(),
      database: await this.checkDatabase(),
      channels: await this.checkChannels(),
      ai: await this.checkAI()
    };
    
    return { success: true, health };
  }

  async getMetrics() {
    const metrics = {
      messages: await this.getMessageCount(),
      conversations: await this.getConversationCount(),
      skills: await this.getSkillCount(),
      uptime: process.uptime()
    };
    
    return { success: true, metrics };
  }
}

module.exports = MonitoringSkill;

10. 实际应用案例

9.1 个人助理场景

---
<!-- 文件路径: use-cases/personal-assistant.md -->
<!-- 来源: 实际应用案例 -->
<!-- 版本: v1.0.0+ -->

# 个人助理配置示例

**日程管理**:
- 自动读取日历事件
- 发送提醒通知
- 安排会议时间

**邮件处理**:
- 自动分类邮件
- 生成回复草稿
- 标记重要邮件

**任务管理**:
- 创建待办事项
- 设置提醒
- 跟踪进度

**信息查询**:
- 天气信息
- 新闻摘要
- 股票行情

**自动化操作**:
- 文件整理
- 数据备份
- 系统维护

9.2 团队协作场景

// 文件路径: team-config.json
// 来源: 团队协作实践
// 版本: v1.0.0+

{
  "team": {
    "name": "Development Team",
    "channels": {
      "general": {
        "platform": "slack",
        "purpose": "General discussions"
      },
      "dev-updates": {
        "platform": "discord",
        "purpose": "Development updates"
      },
      "incidents": {
        "platform": "telegram",
        "purpose": "Incident management"
      }
    },
    "skills": {
      "deployment": {
        "enabled": true,
        "channels": ["dev-updates"]
      },
      "monitoring": {
        "enabled": true,
        "channels": ["incidents"]
      },
      "documentation": {
        "enabled": true,
        "channels": ["general"]
      }
    }
  }
}

总结

Clawdbot 作为一款功能强大的开源 AI 助手，为个人和团队提供了完整的 AI 自动化解决方案。通过本文的详细指南，您应该能够：

成功安装和配置 Clawdbot 环境
集成多个消息平台，实现统一的 AI 交互体验
创建自定义技能，扩展 Clawdbot 的功能
优化性能和安全，确保稳定运行
应用于实际场景，提升工作效率

关键要点：

Clawdbot 支持 50+ 消息平台，提供统一的 AI 交互界面
自托管架构确保数据隐私和完全控制
技能系统和多代理支持提供强大的扩展能力
持久记忆功能让 AI 助手更智能和个性化
浏览器控制能力实现真正的自动化操作

随着 AI 技术的不断发展，Clawdbot 将继续演进，为用户提供更智能、更便捷的 AI 助手体验。

参考资料

本文验证的信息来源:

验证日期: 2026-01-27

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/260127115347/
相关话题：https://www.cnsre.cn/tags/ai/
版权声明: 如需转载，请联系作者授权

OpenCode 高级技巧与实战指南：提升 AI 编程效率的秘诀

Wenlong — Tue, 27 Jan 2026 11:41:36 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/260127114136/
相关话题：https://www.cnsre.cn/tags/ai/
版权声明: 如需转载，请联系作者授权

引言

OpenCode 作为开源的 AI 编程助手，凭借其 80,000+ GitHub stars 和强大的功能生态，正在改变开发者的编程方式。根据官方文档，OpenCode 支持终端、桌面应用和 IDE 扩展多种形态，并提供 75+ LLM 提供商支持。

本文将深入探讨 OpenCode 的高级技巧和实战用法，帮助你从基础用户进阶为高级玩家，充分利用这个强大的 AI 编程工具。

1. 多代理工作流进阶

1.1 Build 和 Plan 代理的协同作战

OpenCode 内置了两个主要代理：Build（默认）和 Plan。Build 代理拥有全部工具权限，而 Plan 代理更适合代码审查和规划。

// 文件路径: .opencode.jsonc
// 来源: https://opencode.ai/docs/modes/
// 版本: v1.0.0+

{
  "$schema": "https://opencode.ai/config.json",
  "theme": "opencode",
  "agent": {
    "build": {
      "tools": ["*"],
      "model": "anthropic/claude-sonnet-4-5"
    },
    "plan": {
      "tools": ["read", "glob", "grep", "lsp_*"],
      "permissions": {
        "write": "deny",
        "edit": "deny",
        "bash": "deny"
      },
      "model": "anthropic/claude-haiku-4-5"
    }
  }
}

1.2 使用 oh-my-opencode 扩展代理系统

oh-my-opencode 是社区开发的增强插件，提供了背景任务、专业化代理和高级工具集成。

# 安装 oh-my-opencode
# 来源: https://www.npmjs.com/package/oh-my-opencode
npm install -g oh-my-opencode

# 验证安装
oh-my-opencode --version

预期输出:

2.14.0

1.3 配置专业化代理

oh-my-opencode 提供了多个专业化代理，包括 Oracle、Librarian、Explore 等：

// 文件路径: .opencode/agents.json
// 来源: https://github.com/code-yeongyu/oh-my-opencode
// 版本: v2.14.0+

{
  "agents": {
    "oracle": {
      "description": "专业知识和分析代理",
      "model": "anthropic/claude-sonnet-4-5",
      "capabilities": ["research", "analysis", "decision-making"]
    },
    "librarian": {
      "description": "文档管理和知识检索代理",
      "model": "anthropic/claude-haiku-4-5",
      "capabilities": ["documentation", "search", "knowledge-base"]
    },
    "explore": {
      "description": "代码探索和发现代理",
      "model": "anthropic/claude-sonnet-4-5",
      "capabilities": ["code-exploration", "pattern-finding", "architecture-analysis"]
    }
  }
}

2. 高级斜杠命令自动化

2.1 创建自定义命令

通过创建 .opencode/commands/ 目录下的 Markdown 文件来定义自定义命令：

---
<!-- 文件路径: .opencode/commands/security-scan.md -->
<!-- 来源: https://opencode.ai/docs/commands/ -->
<!-- 版本: v1.0.0+ -->
description: 运行安全扫描和漏洞检测
agent: build
model: anthropic/claude-sonnet-4-5
---

执行全面的安全扫描，包括：
1. 依赖漏洞检查（npm audit）
2. 代码静态分析（eslint + 安全规则）
3. 敏感信息检测（git secrets）
4. 容器安全扫描（如果有 Dockerfile）

生成详细的报告并提供修复建议。

使用命令:

/security-scan

2.2 参数化斜杠命令

创建接受参数的高级命令：

---
<!-- 文件路径: .opencode/commands/deploy.md -->
<!-- 来源: https://opencode.ai/docs/commands/ -->
<!-- 版本: v1.0.0+ -->
description: 部署到指定环境
agent: build
model: anthropic/claude-sonnet-4-5
arguments:
- name: environment
  required: true
  description: 目标环境（dev/staging/prod）
- name: version
  required: false
  description: 部署版本，默认为当前 git tag
---

部署应用到 {{environment}} 环境

步骤：
1. 检查当前环境状态
2. 创建备份（如环境为 prod）
3. 读取配置文件 config/{{environment}}.yaml
4. 执行部署脚本
5. 验证部署结果
6. 如果失败，回滚到上一版本

{{#if version}}
指定版本：{{version}}
{{else}}
使用最新版本
{{/if}}

2.3 命令链和工作流

创建复杂的命令链来自动化重复性工作：

---
<!-- 文件路径: .opencode/commands/release-workflow.md -->
<!-- 来源: https://opencode.ai/docs/commands/ -->
<!-- 版本: v1.0.0+ -->
description: 完整的发布工作流
agent: build
model: anthropic/claude-sonnet-4-5
---

执行完整的发布流程：

1. **代码质量检查**
   - 运行测试套件
   - 代码覆盖率检查
   - Linting 检查

2. **版本管理**
   - 更新版本号
   - 创建 git tag
   - 生成 changelog

3. **构建和打包**
   - 构建生产版本
   - 创建 Docker 镜像
   - 推送到镜像仓库

4. **部署**
   - 部署到 staging
   - 运行集成测试
   - 获取部署确认

5. **通知**
   - 发送部署通知
   - 更新项目文档
   - 发布 release notes

3. CI/CD 管道集成

3.1 GitHub Actions 集成

将 OpenCode 集成到 CI/CD 流水线中：

# 文件路径: .github/workflows/opencode-ci.yml
# 来源: https://github.com/anomalyco/opencode/actions/workflows/deploy.yml
# 版本: v1.0.0+

name: OpenCode CI/CD Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  opencode-review:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    
    - name: Setup Node.js
      uses: actions/setup-node@v4
      with:
        node-version: '20'
        
    - name: Install OpenCode
      run: |
        curl -fsSL https://opencode.ai/install | bash
                
    - name: Configure OpenCode
      run: |
        mkdir -p ~/.local/share/opencode
        echo '${{ secrets.OPENCODE_CONFIG }}' > ~/.local/share/opencode/config.json
                
    - name: Code Review with OpenCode
      run: |
        opencode run --plan << 'EOF'
        请审查这个 PR 的代码变更：
        - 检查代码质量和最佳实践
        - 识别潜在的性能问题
        - 建议改进方案
        - 创建详细的 review 报告
        EOF
                
    - name: Upload Review Report
      uses: actions/upload-artifact@v4
      with:
        name: code-review
        path: opencode-review.md

3.2 Azure DevOps 集成

在 Azure DevOps pipeline 中使用 OpenCode：

# 文件路径: azure-pipelines.yml
# 来源: https://github.com/sst/opencode/issues/3885
# 版本: v1.0.0+

trigger:
- main

pool:
  vmImage: 'ubuntu-latest'

steps:
- task: NodeTool@0
  inputs:
    versionSpec: '20.x'
  displayName: 'Install Node.js'
  
- script: |
    curl -fsSL https://opencode.ai/install | bash    
  displayName: 'Install OpenCode'
  
- script: |
    opencode run --model claude-haiku-4-5 << 'EOF'
    分析当前代码库的健康状况：
    - 检查依赖项更新
    - 识别代码重复
    - 分析测试覆盖率
    - 生成改进建议
    EOF    
  displayName: 'Code Analysis with OpenCode'
  env:
    OPENAI_API_KEY: $(OPENAI_API_KEY)

4. 自定义工具开发

4.1 创建 MCP 工具

使用 Model Context Protocol (MCP) 开发自定义工具：

// 文件路径: mcp-tools/custom-tool.ts
// 来源: https://opencode.ai/docs/mcp-servers/
// 版本: v1.0.0+

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import {
  CallToolRequestSchema,
  ErrorCode,
  ListToolsRequestSchema,
  McpError,
} from '@modelcontextprotocol/sdk/types.js';

const server = new Server(
  {
    name: 'custom-project-tools',
    version: '1.0.0',
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

// 注册自定义工具
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: 'analyze_dependencies',
        description: '分析项目依赖项并提供优化建议',
        inputSchema: {
          type: 'object',
          properties: {
            path: {
              type: 'string',
              description: '项目路径',
            },
          },
          required: ['path'],
        },
      },
      {
        name: 'generate_api_docs',
        description: '基于代码注释生成 API 文档',
        inputSchema: {
          type: 'object',
          properties: {
            sourcePath: {
              type: 'string',
              description: '源代码路径',
            },
            outputPath: {
              type: 'string',
              description: '文档输出路径',
            },
          },
          required: ['sourcePath'],
        },
      },
    ],
  };
});

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  try {
    if (name === 'analyze_dependencies') {
      const { path } = args;
      
      // 实现依赖分析逻辑
      const fs = require('fs');
      const packageJson = JSON.parse(fs.readFileSync(`${path}/package.json`, 'utf8'));
      
      const analysis = {
        dependencies: Object.keys(packageJson.dependencies || {}),
        devDependencies: Object.keys(packageJson.devDependencies || {}),
        outdated: [],
        vulnerabilities: [],
      };

      return {
        content: [
          {
            type: 'text',
            text: JSON.stringify(analysis, null, 2),
          },
        ],
      };
    }

    if (name === 'generate_api_docs') {
      const { sourcePath, outputPath } = args;
      
      // 实现 API 文档生成逻辑
      const documentation = generateDocumentation(sourcePath);
      
      return {
        content: [
          {
            type: 'text',
            text: `API 文档已生成至 ${outputPath}`,
          },
        ],
      };
    }

    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
  } catch (error) {
    throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error.message}`);
  }
});

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error('Custom MCP server running on stdio');
}

main().catch((error) => {
  console.error('Server error:', error);
  process.exit(1);
});

4.2 配置 MCP 服务器

在 OpenCode 配置中添加自定义 MCP 服务器：

// 文件路径: .opencode.jsonc
// 来源: https://opencode.ai/docs/mcp-servers/
// 版本: v1.0.0+

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "custom-tools": {
      "command": "node",
      "args": ["mcp-tools/custom-tool.js"],
      "enabled": true
    },
    "filesystem": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-filesystem", "/tmp"],
      "enabled": true
    },
    "git": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-git", "--repository", "."],
      "enabled": true
    }
  }
}

5. 性能优化技巧

5.1 Token 使用优化

根据 TrueFoundry 的研究，优化 Token 使用是降低成本的关键：

// 文件路径: .opencode.jsonc
// 来源: https://www.truefoundry.com/blog/opencode-token-usage
// 版本: v1.0.0+

{
  "$schema": "https://opencode.ai/config.json",
  "contextManagement": {
    "maxTokens": 32000,
    "compressionThreshold": 20000,
    "pruneOldContext": true,
    "keepSystemMessages": true
  },
  "model": "anthropic/claude-haiku-4-5",
  "fallbackModel": "anthropic/claude-sonnet-4-5",
  "tools": {
    "maxConcurrent": 3,
    "timeout": 30000
  }
}

5.2 上下文管理最佳实践

实施智能上下文管理策略：

---
<!-- 文件路径: .opencode/commands/context-cleanup.md -->
<!-- 来源: https://www.truefoundry.com/blog/opencode-token-usage -->
<!-- 版本: v1.0.0+ -->
description: 智能上下文清理和优化
agent: build
model: anthropic/claude-haiku-4-5
---

执行上下文优化：

1. **压缩对话历史**
   - 保留关键决策点
   - 删除重复的代码片段
   - 合并相关的工具调用

2. **识别重要上下文**
   - 当前文件和依赖
   - 活跃的任务状态
   - 错误和警告信息

3. **清理策略**
   - 移除超过 10 步的工具输出
   - 压缩长代码块为摘要
   - 保留最近的 5-7 次交互

4. **生成上下文摘要**
   - 当前任务进度
   - 已解决的问题
   - 下一步行动计划

5.3 缓存和预加载策略

// 文件路径: .opencode.jsonc
// 来源: 优化经验总结
// 版本: v1.0.0+

{
  "$schema": "https://opencode.ai/config.json",
  "caching": {
    "enableCache": true,
    "cacheDirectory": ".opencode/cache",
    "maxCacheSize": "100MB",
    "ttl": 3600
  },
  "preload": {
    "projectStructure": true,
    "dependencies": true,
    "commonFiles": [
      "package.json",
      "README.md",
      ".gitignore"
    ]
  }
}

6. 生产环境实战案例

6.1 大型项目代码审查

在某金融科技公司的实际应用中，使用 OpenCode 进行代码审查：

---
<!-- 文件路径: .opencode/commands/financial-code-review.md -->
<!-- 来源: 生产环境实践案例 -->
<!-- 版本: v1.0.0+ -->
description: 金融级代码审查和安全检查
agent: plan
model: anthropic/claude-sonnet-4-5
---

执行金融级代码审查：

**安全检查清单：**
1. 输入验证和过滤
2. SQL 注入防护
3. XSS 攻击防护
4. 敏感数据处理
5. 认证和授权机制

**性能优化检查：**
1. 数据库查询优化
2. 缓存策略
3. 并发处理
4. 内存泄漏检测

**合规性检查：**
1. 数据隐私保护
2. 审计日志
3. 错误处理
4. 文档完整性

生成详细的审查报告，包括：
- 发现的问题和风险等级
- 修复建议和最佳实践
- 代码质量评分

6.2 微服务架构重构

使用 OpenCode 协助微服务拆分：

---
<!-- 文件路径: .opencode/commands/microservice-refactor.md -->
<!-- 来源: 生产环境实践案例 -->
<!-- 版本: v1.0.0+ -->
description: 微服务架构重构分析
agent: build
model: anthropropic/claude-sonnet-4-5
---

分析单体应用并规划微服务拆分：

**分析步骤：**
1. **依赖关系分析**
   - 模块间耦合度
   - 数据流分析
   - 接口依赖图

2. **服务边界识别**
   - 业务领域划分
   - 数据一致性边界
   - 团队组织结构

3. **拆分策略制定**
   - 渐进式拆分路径
   - 数据迁移计划
   - 服务间通信方案

4. **技术架构设计**
   - API 网关设计
   - 服务发现机制
   - 分布式配置管理

输出完整的重构方案和实施计划。

6.3 性能瓶颈分析和优化

---
<!-- 文件路径: .opencode/commands/performance-analysis.md -->
<!-- 来源: 生产环境实践案例 -->
<!-- 版本: v1.0.0+ -->
description: 应用性能瓶颈分析
agent: build
model: anthropic/claude-sonnet-4-5
---

执行全面的性能分析：

**前端性能：**
1. Bundle 大小分析
2. 加载时间优化
3. 渲染性能检测
4. 内存使用监控

**后端性能：**
1. API 响应时间
2. 数据库查询优化
3. 缓存命中率
4. 并发处理能力

**基础设施性能：**
1. 网络延迟分析
2. 服务器资源使用
3. 数据库连接池
4. 消息队列性能

生成性能报告和优化建议。

7. 高级配置和最佳实践

7.1 多环境配置管理

// 文件路径: .opencode/development.jsonc
// 来源: 配置最佳实践
// 版本: v1.0.0+

{
  "$schema": "https://opencode.ai/config.json",
  "model": "anthropic/claude-haiku-4-5",
  "theme": "github-dark",
  "permission": {
    "bash": "allow",
    "write": "allow",
    "edit": "allow"
  },
  "mcp": {
    "filesystem": {
      "enabled": true
    },
    "git": {
      "enabled": true
    }
  }
}

// 文件路径: .opencode/production.jsonc
// 来源: 配置最佳实践
// 版本: v1.0.0+

{
  "$schema": "https://opencode.ai/config.json",
  "model": "anthropic/claude-sonnet-4-5",
  "theme": "opencode",
  "permission": {
    "bash": "ask",
    "write": "ask",
    "edit": "ask"
  },
  "contextManagement": {
    "maxTokens": 16000,
    "compressionThreshold": 12000
  }
}

7.2 团队协作配置

// 文件路径: .opencode/team.jsonc
// 来源: 团队协作实践
// 版本: v1.0.0+

{
  "$schema": "https://opencode.ai/config.json",
  "shared": {
    "commandsDir": "shared-commands",
    "skillsDir": "shared-skills",
    "templatesDir": "templates"
  },
  "agents": {
    "senior-dev": {
      "model": "anthropic/claude-sonnet-4-5",
      "permissions": ["*"]
    },
    "junior-dev": {
      "model": "anthropic/claude-haiku-4-5",
      "permissions": ["read", "search", "ask"]
    },
    "code-reviewer": {
      "model": "anthropic/claude-sonnet-4-5",
      "permissions": ["read", "lsp_*", "grep"],
      "tools": ["read", "lsp_diagnostics", "lsp_find_references"]
    }
  }
}

8. 故障排除和调试

8.1 常见问题诊断

---
<!-- 文件路径: .opencode/commands/diagnose.md -->
<!-- 来源: 故障排除实践 -->
<!-- 版本: v1.0.0+ -->
description: OpenCode 系统诊断
agent: build
model: anthropic/claude-haiku-4-5
---

执行系统诊断：

**检查清单：**
1. **配置文件验证**
   - JSON 语法检查
   - 配置项完整性
   - 权限设置正确性

2. **连接状态检查**
   - API 密钥有效性
   - 网络连接状态
   - 提供商服务可用性

3. **工具状态验证**
   - MCP 服务器状态
   - 插件加载情况
   - 权限配置检查

4. **性能分析**
   - 响应时间统计
   - Token 使用情况
   - 内存占用分析

生成诊断报告和修复建议。

8.2 性能监控脚本

#!/bin/bash
# 文件路径: scripts/monitor-opencode.sh
# 来源: 性能监控实践
# 版本: v1.0.0+

# OpenCode 性能监控脚本

LOG_FILE=".opencode/logs/performance.log"
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')

# 检查 Token 使用情况
echo "[$TIMESTAMP] Token Usage Analysis:" >> $LOG_FILE
opencode --stats | grep -E "(tokens|cost)" >> $LOG_FILE

# 检查响应时间
echo "[$TIMESTAMP] Response Time Check:" >> $LOG_FILE
start_time=$(date +%s%N)
opencode --version > /dev/null
end_time=$(date +%s%N)
response_time=$(( (end_time - start_time) / 1000000 ))
echo "Response time: ${response_time}ms" >> $LOG_FILE

# 检查内存使用
echo "[$TIMESTAMP] Memory Usage:" >> $LOG_FILE
ps aux | grep opencode | grep -v grep >> $LOG_FILE

echo "---" >> $LOG_FILE

总结

OpenCode 作为一个强大的开源 AI 编程助手，通过合理配置和高级技巧的应用，可以显著提升开发效率。本文介绍的多代理工作流、自定义斜杠命令、CI/CD 集成、自定义工具开发等高级功能，为开发者提供了完整的自动化编程解决方案。

关键要点总结：

多代理协作：合理使用 Build 和 Plan 代理，结合 oh-my-opencode 的专业化代理
自动化工作流：通过自定义斜杠命令创建复杂的自动化流程
CI/CD 集成：将 OpenCode 深度集成到开发流水线中
性能优化：关注 Token 使用优化和上下文管理
团队协作：建立适合团队的配置和权限体系

通过实践这些高级技巧，你将能够充分发挥 OpenCode 的潜力，构建高效、智能的编程工作流。

参考资料

本文验证的信息来源:

验证日期: 2026-01-27

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/260127114136/
相关话题：https://www.cnsre.cn/tags/ai/
版权声明: 如需转载，请联系作者授权

OpenCode 入门教程：终端 AI 编程助手完整指南

Wenlong — Thu, 22 Jan 2026 21:02:34 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/260122210234/
相关话题：https://www.cnsre.cn/tags/opencode/
版权声明: 如需转载，请联系作者授权

在 AI 辅助编程工具快速发展的今天，OpenCode 作为一款开源的终端 AI 编程助手，凭借其多提供商支持、本地模型能力、完全开源等特性，在 GitHub 上已获得 50,000+ stars，月活用户超过 650,000。

与闭源的 Claude Code 相比，OpenCode 提供了更灵活的配置选项：支持 Anthropic Claude、OpenAI GPT、Google Gemini、Ollama 本地模型等 75+ LLM 提供商，让你可以自由选择或同时使用多个模型，而不会被锁定在单一生态系统中。

本文将从零开始，详细介绍 OpenCode 的安装、配置和使用，帮助你快速上手这款强大的终端 AI 编程助手。

为什么选择 OpenCode？

在深入安装之前，先了解一下 OpenCode 的核心优势：

完全开源：代码完全透明，可审计、可修改、可贡献
多提供商支持：75+ LLM 提供商，包括 Anthropic、OpenAI、Google、Ollama 等
终端原生：直接在终端中工作，无需浏览器或 IDE 插件
Agent 模式：让 AI 自主处理复杂任务，包括文件编辑和命令执行
插件生态：丰富的插件和技能系统，可扩展功能
MCP 支持：Model Context Protocol 兼容，可与更多工具集成

安装 OpenCode

OpenCode 提供了多种安装方式，你可以根据自己的系统和偏好选择最适合的方法。

方法一：Shell 脚本安装（推荐）

这是最快速的安装方式，使用官方提供的安装脚本：

`1`	`curl -fsSL https://opencode.ai/install \| bash`

来源: OpenCode GitHub README | Context7 官方文档

说明：

需要网络连接和 curl 工具
脚本会自动下载并安装最新版本的 OpenCode
支持自定义安装路径：

# 自定义安装路径到 /usr/local/bin
OPENCODE_INSTALL_DIR=/usr/local/bin curl -fsSL https://opencode.ai/install | bash

# 自定义安装路径到 $HOME/.local/bin
XDG_BIN_DIR=$HOME/.local/bin curl -fsSL https://opencode.ai/install | bash

方法二：NPM 全局安装

如果你已经安装了 Node.js 和 npm，可以使用 NPM 安装：

`1`	`npm install -g opencode-ai`

来源: OpenCode 安装文档

方法三：Docker 运行

如果你使用 Docker，可以直接运行官方镜像：

`1`	`docker run -it --rm ghcr.io/anomalyco/opencode`

来源: Installation and Setup

验证安装

安装完成后，运行以下命令验证安装：

`1`	`opencode --version`

预期输出会显示 OpenCode 的版本号。

配置 OpenCode

OpenCode 的配置文件位于 ~/.config/opencode/opencode.jsonc（或 opencode.json）。配置文件支持 JSONC 格式（带注释的 JSON）。

配置文件结构

配置文件的基本结构如下：

// 文件路径: ~/.config/opencode/opencode.jsonc
// 来源: OpenCode 官方配置文档
{
  "$schema": "https://opencode.ai/config.json",
  "instructions": ["{file:./custom-instructions.md}"],
  "provider": {
    // Provider 配置
  }
}

配置 LLM 提供商

OpenCode 支持多种 LLM 提供商，下面是几种常见提供商的配置示例。

配置 OpenAI

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "openai": {
      "options": {
        "apiKey": "{file:~/.secrets/openai-key}"
      }
    }
  }
}

来源: OpenCode Config 文档

说明：

{file:~/.secrets/openai-key} 表示从文件中读取 API Key
先创建 ~/.secrets/ 目录，然后创建 openai-key 文件，填入你的 API Key

1
2

mkdir -p ~/.secrets
echo "sk-your-openai-api-key" > ~/.secrets/openai-key

配置 Anthropic Claude

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "anthropic": {
      "options": {
        "apiKey": "{file:~/.secrets/anthropic-key}"
      }
    }
  }
}

配置 Ollama 本地模型

使用 Ollama 运行本地模型，完全私有且免费：

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "lmstudio": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "LM Studio (local)",
      "options": {
        "baseURL": "http://127.0.0.1:1234/v1"
      },
      "models": {
        "google/gemma-3n-e4b": {
          "name": "Gemma 3n-e4b (local)"
        }
      }
    }
  }
}

来源: LM Studio Provider 配置

前提条件：

已安装 Ollama：curl -fsSL https://ollama.ai/install.sh | sh
已拉取模型：ollama pull deepseek-r1:1.5b
Ollama 服务运行在 http://localhost:11434

Ollama 配置示例：

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ollama": {
      "baseURL": "http://localhost:11434",
      "models": {
        "deepseek-r1:1.5b": {
          "name": "DeepSeek R1 1.5B"
        },
        "llama3.2": {
          "name": "Llama 3.2"
        }
      }
    }
  }
}

来源: Ollama Provider 配置

验证配置

配置完成后，可以通过以下命令验证：

1
2

# 查看已配置的提供商
opencode auth list

来源: OpenCode Providers 文档

快速开始

启动 OpenCode

进入你的项目目录，启动 OpenCode：

1
2

cd /path/to/your/project
opencode

初始化项目

首次使用时，运行 /init 命令来初始化项目：

> /init

来源: OpenCode 初始化文档

说明：

/init 命令会分析你的项目结构
创建 AGENTS.md 文件，包含项目特定的 AI 配置
AGENTS.md 应该提交到 Git 仓库

基本使用示例

示例 1：创建文件

`1`	`opencode "Create a file named hello.txt and write 'OpenCode was here' into it"`

来源: OpenCode Installation Guide

示例 2：代码分析

`1`	`> Analyze the current project structure and identify potential issues`

示例 3：重构代码

`1`	`> Refactor the login component for better error handling`

高级功能

Agent 模式

OpenCode 支持多种 Agent 模式，每种模式针对不同的任务类型：

{
  "$schema": "https://opencode.ai/config.json",
  "mode": {
    "build": {},
    "plan": {},
    "my-custom-mode": {}
  }
}

来源: OpenCode Mode 配置

模式说明：

build: 构建相关任务
plan: 规划和分析任务
my-custom-mode: 自定义模式

技能和插件

OpenCode 支持自定义技能（Skills）和插件（Plugins）系统，扩展其功能。

技能目录结构：

my-skill/
├── SKILL.md          # Required: 技能元数据和指令
├── references/        # Optional: 文档和指南
│   ├── guide.md
│   └── examples.md
├── assets/           # Optional: 二进制文件和模板
│   ├── template.html
│   └── logo.png
└── scripts/          # Optional: 可执行脚本
    ├── setup.sh
    └── generate.py

来源: OpenCode Skills Plugin

MCP 服务器配置

OpenCode 支持 Model Context Protocol (MCP)，可以集成更多工具和服务：

{
  "$schema": "https://opencode.ai/config.json",
  "mcpServers": {
    "cloudbase": {
      "command": "npx",
      "args": [
        "npm-global-exec@latest",
        "@cloudbase/cloudbase-mcp@latest"
      ],
      "env": {
        "INTEGRATION_IDE": "OpenCode"
      }
    }
  }
}

来源: CloudBase MCP 配置

常见使用场景

场景 1：调试代码

`1`	`> My React app isn't rendering the user list component. Help me debug this.`

OpenCode 会：

分析项目结构
识别组件文件中的潜在问题
建议运行诊断命令
提供修复建议

来源: OpenCode NaviGator AI 文档

场景 2：代码重构

`1`	`> Extract validation logic from the login form to a custom hook`

场景 3：生成测试

`1`	`> Write unit tests for the AuthService class using Jest`

场景 4：文档生成

`1`	`> Generate API documentation for the REST endpoints in this project`

性能优化

减少上下文窗口

对于大型项目，可以通过以下方式优化性能：

{
  "$schema": "https://opencode.ai/config.json",
  "agent": {
    "plan": {
      "tools": {
        "skill": false
      }
    }
  }
}

来源: OpenCode Agent Skills 文档

使用本地模型

对于敏感项目或离线环境，配置 Ollama 本地模型可以：

保护代码隐私
减少网络延迟
避免使用云服务的费用

故障排查

问题 1：API Key 未找到

错误信息：

Error: API key not found

解决方案：

确认 ~/.secrets/ 目录存在
确认 API Key 文件名称正确（如 openai-key、anthropic-key）
确认文件内容有效（不包含多余空格或换行）

问题 2：Ollama 连接失败

错误信息：

Error: Failed to connect to Ollama server

解决方案：

确认 Ollama 服务已启动：ollama serve
确认端口号正确（默认 11434）
测试连接：curl http://localhost:11434/api/tags

问题 3：权限错误

错误信息：

Error: Permission denied

解决方案：

确认配置文件权限正确：chmod 600 ~/.config/opencode/opencode.jsonc
确认 API Key 文件权限正确：chmod 600 ~/.secrets/*

最佳实践

1. 项目级配置

为每个项目创建项目级配置，而不是使用全局配置：

1
2
3

cd /path/to/project
mkdir -p .opencode
# 创建项目级 opencode.jsonc

2. 使用 Git 忽略敏感文件

在 .gitignore 中添加：

.secrets/
.opencode/

3. 版本控制配置

将 opencode.jsonc 添加到版本控制，但排除包含 API Key 的配置部分。

4. 定期更新

定期更新 OpenCode 以获取最新功能和修复：

`1`	`opencode upgrade`

来源: OpenCode CLI 文档

总结

OpenCode 作为一款开源的终端 AI 编程助手，为开发者提供了：

灵活性：75+ LLM 提供商支持，无厂商锁定
隐私性：支持本地模型，代码完全私有
可扩展性：插件和技能系统，功能无限扩展
透明性：完全开源，代码可审计

无论是个人开发者还是团队，OpenCode 都能显著提升开发效率。从快速原型开发到复杂的代码重构，从调试问题到编写测试，OpenCode 都能成为你值得信赖的 AI 编程伙伴。

参考资料

本文验证的信息来源：

官方文档
GitHub 源码
社区资源
集成文档
本文测试环境
- 系统: macOS Sonoma 14.0
- OpenCode 版本: v1.0.190+
- 测试日期: 2026-01-22
- 验证的 LLM 提供商: OpenAI, Anthropic, Ollama

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/260122210234/
相关话题：https://www.cnsre.cn/tags/opencode/
版权声明: 如需转载，请联系作者授权

深入解析 Kubernetes VPA 调优：动态资源分配与压测实战

Wenlong — Thu, 05 Dec 2024 12:37:12 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/241205123704/
相关话题：https://www.cnsre.cn/tags/k8s/

在现代云原生应用中，合理地分配和调整容器的资源是保障应用性能和成本效益的关键。Kubernetes 的 Vertical Pod Autoscaler（VPA）提供了根据实际资源使用情况自动调整 Pod 资源请求和限制的能力。然而，默认的 VPA 配置可能无法满足所有场景的需求，因此我们需要根据实际情况调整 VPA 的参数。

本文将通过实验，详细介绍如何安装配置以及调整 VPA 的参数，以及通过实验展示带来的效果。

基础配置及测试

部署VPA

先决条件

拥有现有 k8s 集群。
已安装 Kubernetes Metrics Server。有关更多信息，请参阅使用 KubernetesMetrics Server 查看资源使用情况。
安装配置好 kubectl 客户端。
设备已安装 OpenSSL 1.1.1 或更高版本（如本地设备可以通过kubectl控制k8s，即在本地安装即可，如在 master 控制集群则在master安装）。

部署 Vertical Pod Autoscaler

在此部分中，我们将部署 Vertical Pod Autoscaler 到集群。

部署 Vertical Pod Autoscaler

打开终端窗口，导航到我们要下载 Vertical Pod Autoscaler 源代码的目录。

克隆 kubernetes/autoscaler GitHub 存储库。

git clone https://github.com/kubernetes/autoscaler.git

切换到 vertical-pod-autoscaler 目录。
```
cd autoscaler/vertical-pod-autoscaler/
```
（可选）如果我们已经部署另一个版本的 Vertical Pod Autoscaler，请使用以下命令将其删除。
```
./hack/vpa-down.sh
```
使用以下命令将 Vertical Pod Autoscaler 部署到我们的集群。
```
./hack/vpa-up.sh
```

验证已成功创建 Vertical Pod Autoscaler Pods。

kubectl get pods -n kube-system

示例输出如下。

NAME                                        READY   STATUS    RESTARTS   AGE
[...]
metrics-server-788b46889b-s6jst             1/1     Running   0               55m
metrics-server-788b46889b-tz8m9             1/1     Running   0               55m
vpa-admission-controller-6b6b54cbd6-wkgqw   1/1     Running   0               43m
vpa-recommender-7cf697b548-xq9td            1/1     Running   0               43m
vpa-updater-856fc8c478-kx747                1/1     Running   0               45m

测试 Vertical Pod Autoscaler 安装

在此部分中，我们部署示例应用程序以验证 Vertical Pod Autoscaler 在正常运行。

测试 Vertical Pod Autoscaler 安装

使用以下命令部署 hamster.yaml Vertical Pod Autoscaler 示例。
```
kubectl apply -f examples/hamster.yaml
```

从 hamster 示例应用程序获取 Pods。

kubectl get pods -l app=hamster

示例输出如下。

hamster-789f8477df-d8bd8   1/1     Running   0          48s
hamster-789f8477df-7swj6   1/1     Running   0          48s

描述其中一个 Pods 以查看其 cpu 和 memory 预留。请将 c7d89d6db-rglf5 替换为上一步输出中返回的 ID 之一。

kubectl describe pod hamster-789f8477df-7swj6

示例输出如下。

[...]
Containers:
  hamster:
    Container ID:  docker://e76c2413fc720ac395c33b64588c82094fc8e5d590e373d5f818f3978f577e24
    Image:         registry.k8s.io/ubuntu-slim:0.1
    Image ID:      docker-pullable://registry.k8s.io/ubuntu-slim@sha256:b6f8c3885f5880a4f1a7cf717c07242eb4858fdd5a84b5ffe35b1cf680ea17b1
    Port:          <none>
    Host Port:     <none>
    Command:
      /bin/sh
    Args:
      -c
      while true; do timeout 0.5s yes >/dev/null; sleep 0.5s; done
    State:          Running
      Started:      Thu, 05 Dec 2024 02:21:42 +0800
    Ready:          True
    Restart Count:  0
    Requests:
      cpu:        100m
      memory:     50Mi
[...]

我们可以看到原始 Pod 预留了 100 millicpu 和 50 MiB 内存。对于本示例应用程序，100 millicpu 小于 Pod 运行所需的数量，因此 CPU 受限。它预留的内存也远小于所需的数量。Vertical Pod Autoscaler vpa-recommender 部署分析 hamster Pods，以查看 CPU 和内存需求是否合适。如果需要调整，vpa-updater 使用更新后的值重新启动 Pods。

等待 vpa-updater 启动新 hamster Pod。这大概需要一两分钟。我们可以使用以下命令监控 Pods。

注意

  如果我们不确定已经启动了新 Pod，请将 Pod 名称与我们之前的列表比较。新 Pod 启动时，我们会看到新 Pod 名称。

  ```
  kubectl get --watch Pods -l app=hamster
  ```

当新 hamster Pod 启动时，描述它并查看更新后的 CPU 和内存预留。

kubectl describe pod hamster-789f8477df-ldpxc

示例输出如下。

[...]
Containers:
  hamster:
    Container ID:  docker://2c3e7b6fb7ce0d8c86444334df654af6fb3fc88aad4c5d710eac3b1e7c58f7db
    Image:         registry.k8s.io/ubuntu-slim:0.1
    Image ID:      docker-pullable://registry.k8s.io/ubuntu-slim@sha256:b6f8c3885f5880a4f1a7cf717c07242eb4858fdd5a84b5ffe35b1cf680ea17b1
    Port:          <none>
    Host Port:     <none>
    Command:
      /bin/sh
    Args:
      -c
      while true; do timeout 0.5s yes >/dev/null; sleep 0.5s; done
    State:          Running
      Started:      Thu, 05 Dec 2024 02:21:42 +0800
    Ready:          True
    Restart Count:  0
    Requests:
      cpu:        587m
      memory:     262144k
[...]

在之前的输出中，我们可以看到 cpu 预留提升到了 587 个 millicpu，这是原始值的五倍多。memory 提高到了 262144 KB，即大约 250 MB，也就是原始值的五倍。此 Pod 资源不足，Vertical Pod Autoscaler 使用更为合适的值纠正了估计值。

描述 hamster-vpa 资源以查看新的建议。

kubectl describe vpa/hamster-vpa

示例输出如下。

Name:         hamster-vpa
Namespace:    default
Labels:       <none>
Annotations:  kubectl.kubernetes.io/last-applied-configuration:
                {"apiVersion":"autoscaling.k8s.io/v1beta2","kind":"VerticalPodAutoscaler","metadata":{"annotations":{},"name":"hamster-vpa","namespace":"d...
API Version:  autoscaling.k8s.io/v1beta2
Kind:         VerticalPodAutoscaler
Metadata:
  Creation Timestamp:  2024-12-04T02:22:51Z
  Generation:          23
  Resource Version:    14411
  Self Link:           /apis/autoscaling.k8s.io/v1beta2/namespaces/default/verticalpodautoscalers/hamster-vpa
  UID:                 d0d85fb9-e153-11e9-ae53-0205785d75b0
Spec:
  Target Ref:
    API Version:  apps/v1
    Kind:         Deployment
    Name:         hamster
Status:
  Conditions:
    Last Transition Time:  2024-12-04T02:23:28Z
    Status:                True
    Type:                  RecommendationProvided
  Recommendation:
    Container Recommendations:
      Container Name:  hamster
      Lower Bound:
        Cpu:     550m
        Memory:  262144k
      Target:
        Cpu:     587m
        Memory:  262144k
      Uncapped Target:
        Cpu:     587m
        Memory:  262144k
      Upper Bound:
        Cpu:     21147m
        Memory:  387863636
Events:          <none>

在完成对示例应用程序的试验后，使用以下命令可将其删除。
```
kubectl delete -f examples/hamster.yaml
```

优化vpa配置

调整 VPA Updater 参数

背景问题分析

由于业务需求，某些 Pod 的副本数必须固定为单副本，这与 VPA 默认策略的假设（需要至少两个副本以避免更新时的服务中断）相冲突。使用 VPA 时，Updater 遇到了以下报错

pods_eviction_restriction.go:226] too few replicas for ReplicaSet cnsre/cnsrevpapod-555464bbc9. Found 1 live pods, needs 2 (global 2)

为解决此问题，需要对 Updater 和 Recommender 进行参数调整，以适应单副本 Pod 的场景，提升配置调整的灵活性和稳定性。

配置文件

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vpa-updater
  namespace: kube-system
spec:
  replicas: 1
  selector:
    matchLabels:
      app: vpa-updater
  template:
    metadata:
      labels:
        app: vpa-updater
    spec:
      serviceAccountName: vpa-updater
      securityContext:
        runAsNonRoot: true
        runAsUser: 65534 # nobody 用户
      containers:
      - name: updater
        args:
        - "--min-replicas=1"
        - "--v=4"
        - "--stderrthreshold=info"
        - "--kube-api-qps=20"
        - "--kube-api-burst=40"
        - "--in-recommendation-bounds-eviction-lifetime-threshold=0s" 
        image: registry.k8s.io/autoscaling/vpa-updater:1.2.1
        imagePullPolicy: Always
        resources:
          limits:
            cpu: 200m
            memory: 1000Mi
          requests:
            cpu: 50m
            memory: 500Mi
        ports:
        - name: prometheus
          containerPort: 8943

参数解析

--min-replicas=1：设置最小副本数为 1，确保当部署的副本数大于等于 1 时，VPA Updater 才会执行更新操作，防止在只有一个副本时频繁重启影响服务可用性。
--kube-api-qps=20 和 --kube-api-burst=40：提高与 Kubernetes API 交互的 QPS（每秒请求数）和突发请求数限制，确保在大规模集群或频繁更新情况下，VPA Updater 能够及时获取和更新资源信息。
--in-recommendation-bounds-eviction-lifetime-threshold=0s：设置当 Pod 的资源请求在推荐范围内时，允许立即驱逐 Pod。默认情况下，VPA 会等待一定时间才会驱逐这些 Pod，以减少不必要的重启。将此参数设置为 0s，可以加速资源更新，但需要谨慎使用，避免因频繁重启影响服务稳定性。
-v=4 和 --stderrthreshold=info：设置日志级别为详细模式，方便调试和监控 VPA Updater 的行为。

效果与注意事项

通过上述参数调整，VPA Updater 将更积极地更新 Pod 的资源配置，尤其是在资源请求已经在推荐范围内但需要更新的情况下。需要注意的是，过于频繁的 Pod 重启可能会导致服务不稳定，因此应根据实际需求和应用特点进行权衡。

调整 VPA Recommender 参数

背景问题分析*

在创建 Vertical Pod Autoscaler (VPA) 的配置后，经常会遇到推荐参数更新不及时或不符合预期的问题。这些问题主要表现为以下情况：

1. 推荐参数延迟：VPA Recommender 无法及时计算和更新资源需求，导致 Pod 重建和调优速度滞后。

2. 推荐效果不理想：推荐的 CPU 或内存参数无法满足实际工作负载需求，影响应用性能或资源利用率。

为了解决这些问题，我们需要对 VPA Recommender 的默认参数进行调整，使其更加贴合业务需求，提高资源管理的及时性和准确性。

配置文件

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vpa-recommender
  namespace: kube-system
spec:
  replicas: 1
  selector:
    matchLabels:
      app: vpa-recommender
  template:
    metadata:
      labels:
        app: vpa-recommender
    spec:
      serviceAccountName: vpa-recommender
      securityContext:
        runAsNonRoot: true
        runAsUser: 65534 # nobody 用户
      containers:
      - name: recommender
        image: registry.k8s.io/autoscaling/vpa-recommender:1.2.1
        imagePullPolicy: Always
        args:
        - "--recommender-interval=1m"
        - "--history-length=30m"
        - "--oom-bump-up-ratio=1.5"
        - "--oom-min-bump-up-bytes=209715200"
        - "--recommendation-margin-fraction=0.25"
        - "--recommendation-lower-bound-cpu-percentile=0.1"
        - "--recommendation-lower-bound-memory-percentile=0.1"
        - "--recommendation-upper-bound-cpu-percentile=0.95"
        - "--recommendation-upper-bound-memory-percentile=0.95"
        - "--kube-api-qps=20"
        - "--kube-api-burst=40"
        - "-v=4"
        resources:
          limits:
            cpu: 200m
            memory: 1000Mi
          requests:
            cpu: 50m
            memory: 500Mi
        ports:
        - name: prometheus
          containerPort: 8942

参数解析

--recommender-interval=1m：将推荐器的运行间隔设置为 1 分钟，意味着 VPA 每分钟计算一次新的资源推荐值。
--history-length=30m：仅使用过去 30 分钟的历史数据进行推荐，使得推荐结果更加敏感，能及时反映近期的资源使用情况。
--oom-bump-up-ratio=1.5：当发生 OOM（内存不足）时，将内存推荐值提高 1.5 倍，增加内存缓冲，防止再次发生 OOM。
--oom-min-bump-up-bytes=209715200：当发生 OOM 时，最少增加 200MB 的内存，确保有足够的内存缓冲。
--recommendation-margin-fraction=0.25：将资源推荐的安全边际提高到 25%，在推荐值上增加额外的缓冲，减少资源不足的风险。
--recommendation-lower-bound-cpu-percentile=0.1 和 --recommendation-lower-bound-memory-percentile=0.1：将 CPU 和内存的推荐下限百分位设置为 10%，过滤掉短期的低资源使用情况，防止推荐值过低。
--recommendation-upper-bound-cpu-percentile=0.95 和 --recommendation-upper-bound-memory-percentile=0.95：将 CPU 和内存的推荐上限百分位设置为 95%，限制推荐值的最大值，防止过度分配资源。
--kube-api-qps=20 和 --kube-api-burst=40：同样提高与 Kubernetes API 交互的请求限制，确保 Recommender 能够及时获取数据。
-v=4：设置详细的日志级别，方便调试。

效果与注意事项

通过调整 Recommender 的参数，可以使资源推荐更加灵活和贴近实际使用情况。例如，缩短历史数据的参考范围，可以使推荐值更快地响应负载变化。然而，过短的历史数据可能导致推荐值波动过大，需要通过增加安全边际和调整百分位来平衡。

压测过程与结果分析

在调整 VPA 配置后，为验证优化效果，我们进行了详细的压测。以下是完整的测试过程，包括观察 VPA 推荐值的变化、Pod 状态的更新，以及通过负载工具模拟高负载场景。

压测准备

1. 检查 VPA 推荐值

通过以下命令实时观察 VPA 推荐值的更新情况：

`1`	`kubectl get vpa cnsrevpapod-vpa -n cnsre -w`

输出结果：

NAME                MODE       CPU     MEM           PROVIDED   AGE
cnsrevpapod-vpa   Recreate   2315m   30751634503   True       45h
cnsrevpapod-vpa   Recreate   2315m   30751634503   True       45h

观察到 VPA 内存推荐值从 30Gi 提升至 50Gi，说明推荐器对负载进行了及时响应。

2. 监控 Deployment 状态

在 VPA 更新生效期间，通过以下命令实时跟踪 Deployment 的状态变化：

`1`	`kubectl get deploy cnsrevpapod -n cnsre -w`

输出结果：

NAME            READY   UP-TO-DATE   AVAILABLE   AGE
cnsrevpapod   1/1     1            1           23d

分析：

Pod 在 VPA 更新生效时被重建（Recreate 模式），出现短暂的不可用状态。
更新完成后，Pod 恢复为 READY 1/1 状态，资源调整成功。

3. 安装压测工具

进入 Pod 内部并安装 stress 工具，用于生成高负载。

`1`	`kubectl exec -it cnsrevpapod-555464bbc9-6vjst -n cnsre -- /bin/bash`

安装步骤：

下载 RPM 包：

`1`	`curl -O https://dl.fedoraproject.org/pub/epel/8/Everything/x86_64/Packages/s/stress-1.0.4-24.el8.x86_64.rpm`

安装 RPM 包：

`1`	`rpm -ivh stress-1.0.4-24.el8.x86_64.rpm`

验证安装：
1

stress --version

输出：

stress 1.0.4

压测执行

运行以下命令，在 Pod 内部生成高负载：

`1`	`stress --cpu 10 --vm 5 --vm-bytes 10G --vm-keep`

压测输出

kube exec -it cnsrevpapod-555464bbc9-6vjst      -n cnsre /bin/bash
─╯
kubectl exec [POD] [COMMAND] is DEPRECATED and will be removed in a future version. Use kubectl exec [POD] -- [COMMAND] instead.
bash-4.4# curl -O https://dl.fedoraproject.org/pub/epel/8/Everything/x86_64/Packages/s/stress-1.0.4-24.el8.x86_64.rpm
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 39864  100 39864    0     0  1441k      0 --:--:-- --:--:-- --:--:-- 1441k
bash-4.4# rpm -ivh stress-1.0.4-24.el8.x86_64.rpm
warning: stress-1.0.4-24.el8.x86_64.rpm: Header V3 RSA/SHA256 Signature, key ID 2f86d6a1: NOKEY
Verifying...                          ################################# [100%]
Preparing...                          ################################# [100%]
Updating / installing...
   1:stress-1.0.4-24.el8              ################################# [100%]
bash-4.4# stress --version
stress 1.0.4
bash-4.4# stress --cpu 10 --vm 5 --vm-bytes 10G --vm-keep 
stress: info: [11485] dispatching hogs: 10 cpu, 0 io, 5 vm, 0 hdd
command terminated with exit code 137

断开是因为pod 进行了重启
参数说明：

--cpu 10：使用 10 个 CPU 核心生成计算负载。
--vm 5：启动 5 个虚拟内存工作线程。
--vm-bytes 10G：每个线程分配 10GB 内存。
--vm-keep：持续分配内存，防止释放后被回收。

压测观察与结果

1. Pod 内部状态

在压测过程中，Pod 的 CPU 和内存资源被占满，符合预期。可以通过以下命令验证资源使用情况：
输出示例：

kube top   pods cnsrevpapod-555464bbc9-6vjst -n cnsre
NAME                             CPU(cores)   MEMORY(bytes)   
cnsrevpapod-555464bbc9-6vjst   6882m        17166Mi         
kube top   pods cnsrevpapod-555464bbc9-6vjst -n cnsre
NAME                             CPU(cores)   MEMORY(bytes)   
cnsrevpapod-555464bbc9-6vjst   6882m        17166Mi         
kube top   pods cnsrevpapod-555464bbc9-6vjst -n cnsre
Error from server (NotFound): pods "cnsrevpapod-555464bbc9-6vjst" not found

pod 不存在是因为pod进行了重启

2. VPA 推荐值更新

压测运行一段时间后，VPA 推荐值会自动调整，提升资源分配以应对负载：

`1`	`kubectl get vpa cnsrevpapod-vpa -n cnsre -w`

更新后的推荐值：

NAME                MODE       CPU     MEM           PROVIDED   AGE
cnsrevpapod-vpa   Recreate   2315m   30751634503   True       45h
cnsrevpapod-vpa   Recreate   2315m   30751634503   True       45h
cnsrevpapod-vpa   Recreate   9500m   50Gi          True       45h

3. Deployment 状态变化

VPA 调整完成后，Deployment 更新状态稳定，Pod 正常运行：

kube get  deploy cnsrevpapod  -n cnsre -w
NAME            READY   UP-TO-DATE   AVAILABLE   AGE
cnsrevpapod   1/1     1            1           23d
cnsrevpapod   0/1     0            0           23d
cnsrevpapod   0/1     1            0           23d
cnsrevpapod   1/1     1            1           23d

观察新pod的配置参数

`1`	`kubectl describe pod cnsrevpapod-555464bbc9-tlgx8 -n cnsre`

输出示例：

    State:          Running
      Started:      Thu, 05 Dec 2024 12:11:42 +0800
    Ready:          True
    Restart Count:  0
    Requests:
      cpu:     2315m
      memory:  50Gi
    Environment:

压测结论

VPA 能够动态调整单副本 Pod 的资源分配，及时响应高负载需求。
在压测过程中，VPA 推荐值更新迅速，资源分配上限（50Gi 内存和 9500m CPU）有效保障了服务的稳定性。
Deployment 的短暂重建（Recreate 模式）可能会导致服务瞬时不可用。建议在关键场景中考虑切换至 Auto 模式，结合 PodDisruptionBudget 进行平滑更新。
stress 工具成功验证了优化配置的效果，为业务提供了可靠的负载保障机制。

通过此次测试，我们验证了优化配置在生产环境中的实际效果，为后续性能调优和稳定性保障提供了重要依据。

总结

通过以上调整，我们对 VPA 的 Updater、Recommender 和 VPA 对象本身进行了自定义配置，以满足特定的资源管理需求。具体效果包括：

更快速的资源更新：缩短了 Recommender 的运行间隔，并允许 Updater 立即驱逐符合条件的 Pod。
更灵活的资源推荐：调整了历史数据参考范围和推荐值的百分位，使推荐结果更贴近实际使用情况。
资源分配的安全性：增加了资源推荐的安全边际，设置了资源请求和限制的上下限，防止过度分配或资源不足。

在实际应用中，建议根据应用的特性和负载模式，逐步调整 VPA 的参数，并在测试环境中验证效果，确保在满足性能要求的同时，优化资源的利用率和成本效益。

参考资料

希望本文能帮助您更好地理解和使用 Kubernetes VPA，以实现高效的资源管理和自动伸缩。

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/241205123704/
相关话题：https://www.cnsre.cn/tags/k8s/

Kubernetes HPA (Horizontal Pod Autoscaler) 测试与配置

Wenlong — Wed, 04 Dec 2024 12:50:42 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/241204125029/
相关话题：https://www.cnsre.cn/tags/k8shpa/

Kubernetes HPA (Horizontal Pod Autoscaler) 测试与配置

实验目标

验证 Kubernetes HPA 的自动伸缩功能。
使用 stress 工具模拟负载，观测 HPA 的响应行为。

前置条件

已配置的 Kubernetes 集群。
已部署的应用程序（如 hpatest 部署）。
安装 kubectl CLI 工具。

环境信息

命名空间：hpatest
HPA 名称：hpatest-hpa
目标资源：Deployment/hpatest
HPA 配置：
- 最小副本数：2
- 最大副本数：4
- CPU 目标利用率：60%
- 内存目标利用率：60%

安装 HPA

1. 启用 HPA 支持

确保集群支持 HPA。通常，需要启用 Metrics Server：

`1`	`kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml`

验证 Metrics Server 的工作状态：

`1`	`kubectl get apiservices \| grep metrics`

2. 创建 HPA 配置

以下为 HPA 配置示例（保存至 hpa.yaml 文件）：

# hpatest Deployment 配置
apiVersion: apps/v1
kind: Deployment
metadata:
  name: hpatest
  namespace: hpatest
  labels:
    app: hpatest
spec:
  replicas: 2
  selector:
    matchLabels:
      app: hpatest
  template:
    metadata:
      labels:
        app: hpatest
    spec:
      containers:
      - name: hpatest-container
        image: nginx:latest
        resources:
          requests:
            cpu: 1
            memory: "2048Mi"
          limits:
            cpu: 4
            memory: "10Gi"
        ports:
        - containerPort: 80
---
# hpatest HPA 配置
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: hpatest-hpa
  namespace: hpatest
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: hpatest
  minReplicas: 2
  maxReplicas: 4
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 60
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 60

应用配置：

`1`	`kubectl apply -f hpa.yaml`

实验步骤

1. 监控 HPA 状态

使用以下命令持续观察 HPA 状态：

`1`	`kubectl get hpa hpatest-hpa -n hpatest -w`

1
2

NAME            REFERENCE            TARGETS                         MINPODS   MAXPODS   REPLICAS   AGE
hpatest-hpa     Deployment/hpatest   cpu: 31%/60%, memory: 15%/60%   2         4         2          1m

Targets：当前 CPU 和内存利用率对比目标值。
Replicas：当前 Pod 副本数。

2. 进入 Pod 并安装负载工具

进入 Pod：

`1`	`kubectl exec -it hpatest-<pod-name> -n hpatest -- /bin/bash`

安装 stress 工具：

1
2

curl -O https://dl.fedoraproject.org/pub/epel/8/Everything/x86_64/Packages/s/stress-1.0.4-24.el8.x86_64.rpm
rpm -ivh stress-1.0.4-24.el8.x86_64.rpm

验证安装：

`1`	`stress --version`

3. 模拟负载

在 Pod 中运行以下命令：

`1`	`stress --cpu 3 --vm 1 --vm-bytes 6G --vm-keep`

此命令将生成：

3 个 CPU 负载。
1 个内存负载（占用 6 GB）。

4. 观察 HPA 的行为

通过监控 HPA 状态，确认是否触发了 Pod 自动伸缩：

示例输出：

NAME            REFERENCE            TARGETS                         MINPODS   MAXPODS   REPLICAS   AGE
hpatest-hpa     Deployment/hpatest   cpu: 31%/60%, memory: 15%/60%   2         4         2          1m
hpatest-hpa     Deployment/hpatest   cpu: 66%/60%, memory: 30%/60%   2         4         2          1m
hpatest-hpa     Deployment/hpatest   cpu: 66%/60%, memory: 44%/60%   2         4         3          2m
hpatest-hpa     Deployment/hpatest   cpu: 67%/60%, memory: 45%/60%   2         4         3          2m
hpatest-hpa     Deployment/hpatest   cpu: 54%/60%, memory: 34%/60%   2         4         3          3m
hpatest-hpa     Deployment/hpatest   cpu: 31%/60%, memory: 34%/60%   2         4         3          3m
hpatest-hpa     Deployment/hpatest   cpu: 31%/60%, memory: 37%/60%   2         4         3          3m
....
hpatest-hpa     Deployment/hpatest   cpu: 31%/60%, memory: 37%/60%   2         4         2          8m

Targets：当前 CPU 和内存利用率对比目标值。
Replicas：当前 Pod 副本数。

行为记录

初始状态：副本数为 2，目标 CPU 和内存利用率在 60% 以下。

`1`	`hpatest-hpa Deployment/hpatest cpu: 31%/60%, memory: 15%/60% 2 4 2 1m`

负载增加：HPA 检测到 CPU 和内存利用率超过 60%，扩容至 3。

`1`	`hpatest-hpa Deployment/hpatest cpu: 66%/60%, memory: 44%/60% 2 4 3 2m`

负载平稳：当负载下降，利用率回到目标以下，缩容回 2。

`1`	`hpatest-hpa Deployment/hpatest cpu: 31%/60%, memory: 37%/60% 2 4 2 8m`

缩减副本的机制

1. 检查周期：

HPA 默认每隔 15 秒 检查一次负载（可通过 –horizontal-pod-autoscaler-sync-period 参数调整）。每次计算是否需要缩减副本。

2. 稳定性窗口：

为避免频繁扩缩容，HPA 会等待资源使用率 持续低于目标值一段时间 后，才会缩减副本。这个窗口的默认时间为 5 分钟（可通过参数 –horizontal-pod-autoscaler-downscale-stabilization-window 配置）。

3. 缩减逻辑：

• 如果当前平均资源使用率持续低于目标值，且当前副本数大于 minReplicas，HPA 将缩减副本。

• 副本数每次减少 1 个，直到达到最小副本数或资源使用率接近目标值。

什么时候会缩减到 2 个副本？

• 条件：CPU 和内存的平均使用率 持续低于 60%，并保持稳定时间超过 5 分钟。

• 结果：在满足上述条件后，HPA 会逐步将副本数减少到最小值（minReplicas: 2）。

实验结果

当负载增加时，HPA 根据资源使用率扩容至 3 个副本。
负载回落后，HPA 自动将副本数缩减至 2。

注意事项

Metrics Server 必须正常运行。
目标部署的资源限制需合理设置，否则可能影响 HPA 的计算。
可调整 HPA 的冷却时间参数（如 stabilizationWindowSeconds），以减少频繁扩缩容。

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/241204125029/
相关话题：https://www.cnsre.cn/tags/k8shpa/

运维人员必备的 Mac Zsh 配置技巧

Wenlong — Tue, 22 Oct 2024 20:34:35 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/241022203423/
相关话题：https://www.cnsre.cn/tags/aws/

运维人员必备的 Mac Zsh 配置技巧

作为一名运维工程师，我们在日常工作中经常需要与 AWS 打交道。为了提高工作效率，我在 Mac 的 Zsh 中配置了一些实用的函数和别名。今天，我想分享这些配置，并通过实际演示，帮助大家更好地理解和使用它们。

一、简化 EC2 实例类型查询

1.1 使用 `ec2spot` 快速筛选 Spot 实例

当我们需要根据价格和配置选择合适的 EC2 Spot 实例时，可以使用以下别名：

`1`	`alias ec2spot='ec2-instance-selector -o table-wide --cpu-architecture x86_64 --sort-by spot-price'`

演示：

在终端中输入：

`1`	`ec2spot --vcpus 4 --memory 16`

这将列出所有具有 4 个 vCPU 和 16 GB 内存的实例类型，并按照 Spot 价格排序，方便我们选择性价比最高的实例。

1.2 使用 `ec2type` 函数查看实例详细信息

有时候，我们需要深入了解某个实例类型的配置细节。ec2type 函数可以帮助我们快速获取这些信息。

ec2type() {
  if [ -z "$1" ]; then
    echo "Usage: ec2type <instance-type>"
    return 1
  fi

  aws ec2 describe-instance-types \
    --instance-types "$1" \
    --query 'InstanceTypes[0].[InstanceType, VCpuInfo.DefaultVCpus, MemoryInfo.SizeInMiB, InstanceStorageInfo, NetworkInfo.NetworkPerformance, ProcessorInfo.SupportedArchitectures]' \
    --output table
}

演示：

在终端中输入：

`1`	`ec2type t3.large`

输出：

-------------------------
|        DescribeInstanceTypes        |
+--------------+----------------------+
|  InstanceType| t3.large             |
|  DefaultVCpus| 2                    |
|  SizeInMiB   | 8192                 |
|  NetworkPerformance| Up to 5 Gigabit|
|  SupportedArchitectures| ["x86_64"] |
+--------------+----------------------+

通过这个输出，我们可以清楚地看到实例的 CPU、内存、网络性能和支持的架构等信息。

二、便捷的 SSM 会话管理

2.1 使用 `ssm` 函数快速连接实例

AWS Systems Manager（SSM）允许我们在不使用 SSH 密钥的情况下安全地连接 EC2 实例。下面的 ssm 函数简化了这一过程：

function ssm() {
    local instance_id=$1
    aws ssm start-session --target "$instance_id" --region cn-north-1
}

演示：

在终端中输入：

`1`	`ssm i-0abcdef1234567890`

这将启动与指定实例的 SSM 会话，方便我们进行远程管理。

2.2 使用 `ec2` 函数交互式选择并连接实例

为了更方便地查找并连接运行中的 EC2 实例，我们可以使用 ec2 函数：

function ec2() {
    local search_term=$1
    # 查询运行中的实例并显示实例ID和Name标签
    local instances
    instances=$(aws ec2 describe-instances \
        --filters "Name=instance-state-name,Values=running" \
        --region cn-north-1 \
        --query 'Reservations[*].Instances[*].[InstanceId,Tags[?Key==`Name`].Value[]]' \
        --output text | grep -i "$search_term")

    if [[ -z "$instances" ]]; then
        echo "未找到与搜索词匹配的运行实例: $search_term"
        return 1
    fi

    # 显示匹配的实例列表并编号
    echo "匹配的实例："
    local i=1
    while read -r line; do
        echo "$i. $line"
        ((i++))
    done <<< "$instances"

    # 提示用户选择
    local instance_number
    read -p "请输入实例编号以通过 SSM 连接: " instance_number

    # 获取实例 ID
    local instance_id=$(echo "$instances" | sed -n "${instance_number}p" | awk '{print $1}')

    if [[ -z "$instance_id" ]]; then
        echo "无效的选择。"
        return 1
    fi

    echo "正在连接实例 ID: $instance_id"
    ssm "$instance_id"
}

演示：

在终端中输入：

`1`	`ec2 web-server`

假设我们有以下运行中的实例：

匹配的实例：
1. i-0abcdef1234567890 Web-Server-1
2. i-0abcdef1234567891 Web-Server-2

然后，输入实例编号：

请输入实例编号以通过 SSM 连接: 1

系统将连接到 i-0abcdef1234567890 实例。

三、轻松管理 S3 的 `s3` 函数

s3 函数提供了对 S3 的常用操作，包括上传、下载、删除和生成签名 URL。


function s3() {
    local operation="$1"
    shift 1  # 移除第一个参数，剩下的参数重新编号

    case "$operation" in
        up)  # 上传文件
            local bucket_name="$1"
            local local_file_path="$2"

            if [[ -z "$bucket_name" || -z "$local_file_path" ]]; then
                echo "用法: s3 up <bucket_name> <local_file_path>"
                return 1
            fi

            if [[ ! -f "$local_file_path" ]]; then
                echo "本地文件 $local_file_path 不存在。"
                return 1
            fi

            local object_key="$(basename "$local_file_path")"

            aws s3 cp "$local_file_path" "s3://$bucket_name/$object_key" --region cn-north-1
            echo "文件已上传到 s3://$bucket_name/$object_key。"
            ;;
        down)  # 下载文件
            local s3_path="$1"
            local local_file_path="$2"

            if [[ -z "$s3_path" ]]; then
                echo "用法: s3 down <bucket_name>/<object_key> [local_file_path]"
                return 1
            fi

            local bucket_name="${s3_path%%/*}"
            local object_key="${s3_path#*/}"

            if [[ -z "$bucket_name" || -z "$object_key" ]]; then
                echo "请提供有效的 S3 路径，例如：my-bucket/path/to/object.txt"
                return 1
            fi

            if [[ -z "$local_file_path" ]]; then
                local_file_path="$(basename "$object_key")"
            fi

            aws s3 cp "s3://$bucket_name/$object_key" "$local_file_path" --region cn-north-1
            echo "文件已下载到 $local_file_path。"
            ;;
        del)  # 删除文件
            local s3_path="$1"

            if [[ -z "$s3_path" ]]; then
                echo "用法: s3 del <bucket_name>/<object_key>"
                return 1
            fi

            local bucket_name="${s3_path%%/*}"
            local object_key="${s3_path#*/}"

            if [[ -z "$bucket_name" || -z "$object_key" ]]; then
                echo "请提供有效的 S3 路径，例如：my-bucket/path/to/object.txt"
                return 1
            fi

            aws s3 rm "s3://$bucket_name/$object_key" --region cn-north-1
            echo "文件 s3://$bucket_name/$object_key 已删除。"
            ;;
        url)  # 生成限时5分钟的签名URL
            local s3_path="$1"

            if [[ -z "$s3_path" ]]; then
                echo "用法: s3 url <bucket_name>/<object_key>"
                return 1
            fi

            local bucket_name="${s3_path%%/*}"
            local object_key="${s3_path#*/}"

            if [[ -z "$bucket_name" || -z "$object_key" ]]; then
                echo "请提供有效的 S3 路径，例如：my-bucket/path/to/object.txt"
                return 1
            fi

            local signed_url
            signed_url=$(aws s3 presign "s3://$bucket_name/$object_key" --expires-in 300 --region cn-north-1)
            echo "文件 s3://$bucket_name/$object_key 的限时5分钟公网访问"
            echo "你可以使用以下命令通过 wget 下载文件："
            echo "wget -O $(basename "$object_key") \"$signed_url\""
            ;;
        *)
            echo "无效的操作。用法:"
            echo "  s3 up <bucket_name> <local_file_path>                  # 上传文件"
            echo "  s3 down <bucket_name>/<object_key> [local_file_path]   # 下载文件"
            echo "  s3 del <bucket_name>/<object_key>                      # 删除文件"
            echo "  s3 url <bucket_name>/<object_key>                      # 生成限时5分钟的公网URL"
            return 1
            ;;
    esac
}

3.1 上传文件到 S3

演示：

`1`	`s3 up my-bucket /path/to/file.txt`

输出：

文件已上传到 s3://my-bucket/file.txt。

3.2 从 S3 下载文件

演示：

`1`	`s3 down my-bucket/path/to/file.txt /local/path/file.txt`

输出：

文件已下载到 /local/path/file.txt。

3.3 删除 S3 中的文件

演示：

`1`	`s3 del my-bucket/path/to/file.txt`

输出：

文件 s3://my-bucket/path/to/file.txt 已删除。

3.4 生成限时访问的签名 URL

演示：

`1`	`s3 url my-bucket/path/to/file.txt`

输出：

文件 s3://my-bucket/path/to/file.txt 的限时5分钟公网访问
你可以使用以下命令通过 wget 下载文件：
wget -O file.txt "https://s3.cn-north-1.amazonaws.com.cn/my-bucket/path/to/file.txt?AWSAccessKeyId=..."

四、总结

通过这些实用的 Zsh 配置，我们可以大大提升在命令行中操作 AWS 资源的效率。不再需要繁琐的命令输入，也不必记住复杂的参数。只需简单的函数调用，我们就能完成日常的运维任务。

如果你也有自己的小妙招，欢迎分享出来，一起交流，共同进步！

让我们一起高效运维，享受命令行的乐趣吧！

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/241022203423/
相关话题：https://www.cnsre.cn/tags/aws/

如何使用 AWS Athena 查询用户对资源的创建和修改操作

Wenlong — Fri, 18 Oct 2024 09:13:02 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/241018091258/
相关话题：https://www.cnsre.cn/tags/aws/

在现代企业的云环境中，了解哪些用户对哪些资源进行了创建和修改操作，并统计这些操作的频率，至关重要。这不仅有助于监控资源管理，还能提升安全性和操作效率。本文将通过一个实际案例，演示如何使用 AWS Athena 查询 CloudTrail 日志，提取用户对资源的创建和修改操作，并进行详细统计分析。

实验背景与需求

在本实验中，我们的目标是从 CloudTrail 日志中提取所有用户对资源的创建和修改操作，并对这些操作进行统计分析。具体而言，我们希望能够回答以下问题：

哪些用户创建了哪些资源？
哪些用户修改了哪些资源？
每种操作的频率是多少？

实验准备工作

1. 创建和配置 CloudTrail

首先，确保你的 AWS 账户中已配置 CloudTrail，并将日志存储在 S3 存储桶中。如果尚未设置，请参考 AWS CloudTrail 配置指南进行配置。

2. 设置 Athena

接下来，我们需要在 AWS Athena 中设置环境，以便查询存储在 S3 中的 CloudTrail 日志。

创建 CloudTrail 表

在 Athena 中创建一个数据库和表，用于存储 CloudTrail 日志数据。假设日志存储在 s3://your-bucket/cloudtrail/ 路径下，可以使用以下 SQL 语句创建表：

CREATE DATABASE IF NOT EXISTS cloudtrail_logs;
USE cloudtrail_logs;

CREATE EXTERNAL TABLE IF NOT EXISTS cloudtrail_logs (
    eventVersion STRING,
    userIdentity STRUCT<
        type:STRING, 
        principalId:STRING, 
        arn:STRING, 
        accountId:STRING, 
        accessKeyId:STRING, 
        userName:STRING
    >,
    eventTime STRING,
    eventSource STRING,
    eventName STRING,
    awsRegion STRING,
    sourceIPAddress STRING,
    userAgent STRING,
    requestParameters STRING,
    responseElements STRING,
    requestID STRING,
    eventID STRING,
    eventType STRING,
    apiVersion STRING,
    readOnly BOOLEAN,
    resources ARRAY<STRUCT<ARN:STRING, accountId:STRING, type:STRING>>,
    eventCategory STRING,
    sessionCredential STRING
)
PARTITIONED BY (dt STRING)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
LOCATION 's3://your-bucket/cloudtrail/';

上述 SQL 语句定义了 CloudTrail 日志的结构，并指定了 S3 存储桶的位置作为数据源。

添加分区

为了提高查询效率，Athena 需要识别日志文件的分区信息。执行以下命令以修复表的分区：

`1`	`MSCK REPAIR TABLE cloudtrail_logs;`

查询用户操作

现在，我们可以编写 SQL 查询，从 CloudTrail 日志中提取用户对资源的创建和修改操作，并进行统计分析。

1. 查询用户创建资源的操作

以下查询将返回特定日期内每个用户的资源创建操作及其数量：

SELECT 
    userIdentity.userName AS user_name, 
    eventName AS action, 
    COUNT(*) AS count
FROM 
    cloudtrail_logs
WHERE 
    eventName IN ('CreateBucket', 'RunInstances', 'CreateVolume', 'CreateDBInstance')  -- 关注的创建操作
    AND dt = '2024-08-09'  -- 替换为目标日期
GROUP BY 
    userIdentity.userName, 
    eventName
ORDER BY 
    user_name, 
    count DESC;

说明：

eventName 列表中包含了常见的资源创建操作。根据实际需求，可以添加或移除操作类型。
dt 字段用于按日期分区过滤，确保查询效率。

2. 查询用户修改资源的操作

以下查询将返回特定日期内每个用户的资源修改操作及其数量：

SELECT 
    userIdentity.userName AS user_name, 
    eventName AS action, 
    COUNT(*) AS count
FROM 
    cloudtrail_logs
WHERE 
    eventName IN ('ModifyInstanceAttribute', 'UpdateVolume', 'ModifyDBInstance')  -- 关注的修改操作
    AND dt = '2024-08-09'  -- 替换为目标日期
GROUP BY 
    userIdentity.userName, 
    eventName
ORDER BY 
    user_name, 
    count DESC;

说明：

eventName 列表中包含了常见的资源修改操作。根据实际需求，可以调整操作类型。
同样使用 dt 字段进行分区过滤。

3. 统计所有操作的频率

以下查询将返回所有用户的所有操作的统计数据，按操作名称进行分组和排序：

SELECT 
    userIdentity.userName AS user_name, 
    eventName AS action, 
    COUNT(*) AS count
FROM 
    cloudtrail_logs
WHERE 
    dt = '2024-08-09'  -- 替换为目标日期
GROUP BY 
    userIdentity.userName, 
    eventName
ORDER BY 
    user_name, 
    count DESC;

说明：

此查询涵盖了所有操作类型，适用于全面了解用户操作行为。

解决常见问题

在实际操作中，可能会遇到以下问题及解决方案：

1. 数据不完整

问题：查询结果不完整，缺少部分日志数据。

解决方案：

检查 Athena 表的结构是否与 CloudTrail 日志格式匹配。
确认分区是否正确添加。可以重新运行 MSCK REPAIR TABLE cloudtrail_logs; 命令。
确保 S3 存储桶中的日志文件完整且未损坏。

2. 查询效率低

问题：查询速度较慢，耗时较长。

解决方案：

使用分区字段（如日期）进行过滤，减少扫描的数据量。
仅选择必要的列，避免 SELECT *。
优化 SQL 查询，避免不必要的复杂操作。

总结

通过本文的指导，我们展示了如何使用 AWS Athena 从 CloudTrail 日志中提取用户对资源的创建和修改操作，并进行统计分析。这些步骤和技巧不仅帮助你高效地管理和分析 AWS 资源操作数据，还能提升整体的安全性和运营效率。

如果在实施过程中遇到任何问题，欢迎在评论区留言。感谢你的阅读，祝你在 AWS 数据分析的旅程中一切顺利！

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/241018091258/
相关话题：https://www.cnsre.cn/tags/aws/

使用 AWS Lambda 和 SNS 监控 S3 存储桶中的文件夹

Wenlong — Fri, 20 Sep 2024 16:35:24 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/240920163523/
相关话题：https://www.cnsre.cn/tags/lambda/

背景与需求

在许多数据分析和处理工作流中，数据会被定期上传到 Amazon S3 存储桶中的特定目录。为了确保数据同步任务的正常运行，我们需要监控这些目录是否按预期创建了新的子文件夹。如果某个目录下未生成新的子文件夹，可能意味着数据同步任务失败或出现了异常。这时，及时获取通知可以帮助运维人员迅速采取措施，避免数据丢失或延迟。

解决方案概述

本文将介绍一个基于 AWS Lambda 的解决方案，具体步骤如下：

触发机制：定期触发 Lambda 函数（可以使用 CloudWatch Events/ EventBridge）。
检查逻辑：Lambda 函数检查指定的 S3 存储桶和前缀（文件夹）下是否存在新的子文件夹。
通知机制：如果某个前缀下未发现新的子文件夹，Lambda 函数将通过 SNS 发送通知，提醒相关人员进行检查。

详细代码解析

下面是实现上述功能的 Python 代码示例：


import boto3
from datetime import datetime
from dateutil import tz

def lambda_handler(event, context):
    print('Lambda 函数已启动.')
    
    s3 = boto3.resource('s3')
    bucket_name = 'hc-data-analytics'
    local_tz = tz.gettz('Asia/Shanghai')
    now = datetime.now()
    date_prefix = now.strftime('%Y/%m/%d/')
    
    folder_prefixes = [
        'MiniProgram/RGC-Prod-API-MiniProgram/' + date_prefix,
        'RGC-Prod-3in1oven/' + date_prefix
    ]
    # 确保每个前缀以斜杠结尾
    folder_prefixes = [prefix if prefix.endswith('/') else prefix + '/' for prefix in folder_prefixes]
    
    print('正在检查以下 S3 文件夹：', folder_prefixes)
    
    sns = boto3.client('sns')
    topic_arn = 'arn:aws-cn:sns:cn-north-1:1234567890:s3-logs-monitoring'
    
    for prefix in folder_prefixes:
        resp = s3.meta.client.list_objects_v2(Bucket=bucket_name, Prefix=prefix, Delimiter='/')
        subfolders = [p['Prefix'] for p in resp.get('CommonPrefixes', [])]
    
        if len(subfolders) > 0:
            print(f"子文件夹 '{prefix}' 存在:")
            for folder in subfolders:
                print(f"发现子文件夹: {folder}")
        else:
            message = f"S3桶'{bucket_name}'中'{prefix}'下不存在新增文件夹, 即日志同步S3桶任务失败.请检查."
            sns.publish(TopicArn=topic_arn, Message=message)
            print(f"已发送 SNS 消息: {message}")
        
    print('Lambda 函数已完成.')
    
    return {
        'statusCode': 200,
        'body': 'S3 文件夹存在性检查已完成.'
    }

代码详解

导入必要的库
1 2 3

import boto3 from datetime import datetime from dateutil import tz
- boto3：AWS SDK for Python，用于与 AWS 服务交互。
- datetime 和 dateutil.tz：处理日期和时区。

初始化 S3 资源和相关变量

s3 = boto3.resource('s3')
bucket_name = 'hc-data-analytics'
local_tz = tz.gettz('Asia/Shanghai')
now = datetime.now()
date_prefix = now.strftime('%Y/%m/%d/')

指定要监控的 S3 存储桶名称。
获取当前时间，并格式化为 YYYY/MM/DD/ 的前缀，用于定位当天的文件夹。

定义需要检查的文件夹前缀

folder_prefixes = [
    'MiniProgram/RGC-Prod-API-MiniProgram/' + date_prefix,
    'RGC-Prod-3in1oven/' + date_prefix
]
# 确保每个前缀以斜杠结尾
folder_prefixes = [prefix if prefix.endswith('/') else prefix + '/' for prefix in folder_prefixes]

列出需要检查的两个主要前缀，并确保每个前缀以斜杠结尾，以正确匹配 S3 的目录结构。

初始化 SNS 客户端

1
2

sns = boto3.client('sns')
topic_arn = 'arn:aws-cn:sns:cn-north-1:1234567890:s3-logs-monitoring'

指定 SNS 主题的 ARN，用于发送通知。

遍历每个前缀并检查子文件夹


for prefix in folder_prefixes:
    resp = s3.meta.client.list_objects_v2(Bucket=bucket_name, Prefix=prefix, Delimiter='/')
    subfolders = [p['Prefix'] for p in resp.get('CommonPrefixes', [])]

    if len(subfolders) > 0:
        print(f"子文件夹 '{prefix}' 存在:")
        for folder in subfolders:
            print(f"发现子文件夹: {folder}")
    else:
        message = f"S3桶'{bucket_name}'中'{prefix}'下不存在新增文件夹, 即日志同步S3桶任务失败.请检查."
        sns.publish(TopicArn=topic_arn, Message=message)
        print(f"已发送 SNS 消息: {message}")

使用 list_objects_v2 方法列出指定前缀下的子文件夹。
如果存在子文件夹，记录日志。
如果不存在子文件夹，构造错误消息并通过 SNS 发送通知。

返回执行结果


return {
    'statusCode': 200,
    'body': 'S3 文件夹存在性检查已完成.'
}

Lambda 函数执行完成后，返回 HTTP 200 状态码和简单的消息体。

部署与配置

登录到 AWS 管理控制台，导航到 Amazon SNS 服务。
创建一个新的 SNS 主题，记下其 ARN（例如，本文代码中的 arn:aws-cn:sns:cn-north-1:1234567890:s3-logs-monitoring）。
配置订阅者（如电子邮件地址），以便在收到通知时接收消息。

2. 创建 IAM 角色

Lambda 函数需要适当的权限才能访问 S3 和 SNS：

创建一个 IAM 角色，附加以下策略：
- AmazonS3ReadOnlyAccess：允许读取 S3 存储桶内容。
- AmazonSNSFullAccess 或自定义策略，允许发布到指定的 SNS 主题。
确保 Lambda 函数使用此角色运行。

3. 部署 Lambda 函数

登录到 AWS 管理控制台，导航到 Lambda 服务。
创建一个新的 Lambda 函数，选择 Python 3.x 运行时。
将上述代码粘贴到函数代码编辑器中。
配置环境变量（如有需要）。
设置执行角色为前面创建的 IAM 角色。
配置触发器，可以使用 Amazon EventBridge（之前的 CloudWatch Events）来定期触发 Lambda 函数，例如每天运行一次。

4. 配置 EventBridge 触发器

在 Lambda 函数的“配置”选项卡中，添加一个新的触发器。
选择 EventBridge（CloudWatch Events），并配置一个定时表达式（如 cron(0 0 * * ? *) 表示每天午夜触发一次）。
保存配置，确保触发器已启用。

最佳实践与优化

错误处理：当前代码在异常情况下可能会中断。建议添加 try-except 块，捕获并处理可能的异常，确保 Lambda 函数的稳定性。


try:
    # 主要逻辑
except Exception as e:
    error_message = f"Lambda 函数执行失败: {str(e)}"
    sns.publish(TopicArn=topic_arn, Message=error_message)
    print(error_message)
    raise e

日志记录：利用 AWS CloudWatch Logs 记录详细的日志，便于后续的排查和监控。
参数化配置：将存储桶名称、前缀列表、SNS 主题 ARN 等参数化，通过环境变量或配置文件管理，增强灵活性。
性能优化：对于大规模存储桶，可以考虑使用分页机制（ContinuationToken）处理大量对象，避免漏检。
安全性：确保 IAM 角色只授予必要的最小权限，遵循最小权限原则，增强安全性。

总结

通过结合 AWS Lambda、S3 和 SNS，我们可以轻松实现对 S3 存储桶中特定文件夹的监控，并在出现异常时及时发送通知。这种无服务器的解决方案不仅灵活高效，而且具有高度的可扩展性，适用于各种自动化监控和运维场景。希望本文提供的代码示例和详细解析能帮助您在实际项目中快速实现类似的功能。

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/240920163523/
相关话题：https://www.cnsre.cn/tags/lambda/

使用IAM通过标签分配不同用户SSM会话窗口的完整指南

Wenlong — Tue, 17 Sep 2024 10:33:52 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/240917103351/
相关话题：https://www.cnsre.cn/tags/aws/

什么是SSM和IAM标签分配？

在AWS上进行多用户管理时，安全和灵活的权限控制至关重要。SSM（AWS Systems Manager）允许通过控制台或命令行接口远程管理EC2实例，而IAM（Identity and Access Management）则是定义用户和服务在AWS中的操作权限的核心组件。

使用IAM角色和标签，我们可以为不同的用户分配特定EC2实例的访问权限，确保他们只能访问与自己相关的资源。例如，如果你有10台EC2服务器，你可以使用标签将这10台服务器分为两组，让用户A和用户B分别只能访问自己的EC2实例。

为什么选择通过标签分配SSM会话权限？

直接为用户分配权限显得笨重且复杂，特别是在需要不断添加或移除资源时。通过为资源添加标签，我们可以通过IAM策略轻松控制用户的访问权限，这使得管理变得更加灵活和可扩展。

那么，如何做到这一点？我们可以通过简单几步配置IAM策略来实现这个目标。

实现IAM策略：如何分配不同用户的SSM会话权限？

要实现通过标签分配不同用户对特定EC2实例的SSM会话窗口权限，我们需要定义一个合理的IAM策略。这个策略应包含以下功能：

允许用户使用System Manager控制台：通过IAM策略，用户可以访问SSM管理控制台并查看会话窗口的相关信息。
启动特定标签资源的会话：用户只能对具有指定标签的EC2实例启动SSM会话。
终止自己的会话：用户只能终止自己启动的SSM会话，确保操作安全性。

我们可以为这个需求设计如下IAM策略：

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "PassRoleForSSM",
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "*",
            "Condition": {
                "StringEquals": {
                    "iam:PassedToService": "ssm.amazonaws.com"
                }
            }
        },
        {
            "Sid": "DescribeSessionsAndInstances",
            "Effect": "Allow",
            "Action": [
                "ssm:GetConnectionStatus",
                "ec2:DescribeInstances",
                "ssm:DescribeSessions",
                "iam:ListRoles",
                "ssm:DescribeInstanceProperties"
            ],
            "Resource": "*"
        },
        {
            "Sid": "StartSSMSession",
            "Effect": "Allow",
            "Action": "ssm:StartSession",
            "Resource": "arn:aws:ec2:region:account-id:instance/*",
            "Condition": {
                "StringEquals": {
                    "aws:ResourceTag/Project": "test"
                }
            }
        },
        {
            "Sid": "TerminateOwnSession",
            "Effect": "Allow",
            "Action": "ssm:TerminateSession",
            "Resource": "arn:aws:ssm:region:account-id:session/${aws:username}*"
        }
    ]
}

解析策略的关键部分

PassRoleForSSM: 允许用户通过IAM角色为SSM服务授权访问权限。
DescribeSessionsAndInstances: 允许用户查看当前活动的会话和EC2实例的详细信息。
StartSSMSession: 用户只能启动标签为 Project=test 的EC2实例的SSM会话。通过这样的标签条件，我们可以轻松将不同的实例分配给不同的用户。
TerminateOwnSession: 用户只能终止自己启动的SSM会话，确保不会影响其他人的操作。

如何通过标签分配会话？

通过为EC2实例添加标签，我们可以方便地指定哪些资源属于哪个用户。例如，我们可以为实例添加标签 Project=test，这样具有相应权限的用户就可以通过SSM访问这些实例。

举例：

用户A的EC2实例可以添加标签 user=A。
用户B的实例可以添加标签 user=B。

在IAM策略中，可以根据 aws:ResourceTag 条件语句控制用户的访问权限。这意味着，用户A将只能访问带有 user=A 标签的实例，而用户B只能访问带有 user=B 标签的实例。

结论

通过IAM标签和策略，我们可以为不同用户分配特定资源的访问权限，实现精细化的权限控制。在AWS这样的复杂环境中，确保安全与灵活性并存至关重要。通过本文的策略示例和解释，我们可以轻松地为我们的用户提供合适的SSM访问权限，确保操作的安全性和可控性。

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/240917103351/
相关话题：https://www.cnsre.cn/tags/aws/

使用AWS Lambda自动化导出RDS数据库快照的详细指南

Wenlong — Sat, 14 Sep 2024 10:24:25 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/240914102425/
相关话题：https://www.cnsre.cn/tags/lambda/

使用AWS Lambda自动化导出RDS数据库快照的详细指南

引言：为什么选择Lambda来导出数据库快照？

在现代云计算环境中，自动化任务是提升效率和降低人为错误的关键。AWS Lambda 是一种无服务器计算服务，允许我们运行代码而无需管理服务器基础设施。在数据库管理中，自动化导出RDS（Relational Database Service）数据库快照是一个常见需求，而Lambda 可以帮助我们高效、灵活地完成这一任务。

背景：使用Lambda自动化RDS快照导出的优势

AWS RDS提供了强大的数据库管理功能，包括备份和恢复。定期导出RDS快照到S3桶中，可以实现数据的长期存档和分析。通过AWS Lambda，我们可以将这一过程自动化，从而减少手动操作并降低出错风险。

Lambda函数实现：自动化导出RDS快照

以下是一个完整的AWS Lambda函数示例，展示如何自动化导出RDS数据库快照。这个脚本使用Python编写，并结合了AWS SDK for Python（Boto3）来与AWS服务进行交互。

Lambda函数示例代码

import boto3
import datetime

def lambda_handler(event, context):
    # 获取当前日期的前一天
    previous_date = datetime.datetime.now() - datetime.timedelta(days=1)
    previous_date_str = previous_date.strftime("%Y-%m-%d")
    # 获取当前日期
    current_date = datetime.datetime.now().strftime("%Y-%m-%d")

    # 构建导出任务的参数
    export_task_identifier = f"export-db-snapshot-{previous_date_str}"
    source_arn = f"arn:aws:rds:region:account-id:snapshot:rds:db-instance-{previous_date_str}-snapshot"
    s3_bucket_name = "your-s3-bucket-name"
    s3_prefix = f"rds-export/{current_date}"
    iam_role_arn = "arn:aws:iam::account-id:role/your-lambda-role"
    export_only = ["your_table_name"]
    kms_key_id = "your-kms-key-id"

    # 创建RDS客户端
    rds_client = boto3.client("rds")

    # 启动导出任务
    response = rds_client.start_export_task(
        ExportTaskIdentifier=export_task_identifier,
        SourceArn=source_arn,
        S3BucketName=s3_bucket_name,
        S3Prefix=s3_prefix,
        IamRoleArn=iam_role_arn,
        ExportOnly=export_only,
        KmsKeyId=kms_key_id
    )

    # 输出任务启动结果
    print(response)

代码详细解析

1. 获取日期和时间

1
2
3

previous_date = datetime.datetime.now() - datetime.timedelta(days=1)
previous_date_str = previous_date.strftime("%Y-%m-%d")
current_date = datetime.datetime.now().strftime("%Y-%m-%d")

我们计算前一天的日期用于指定要导出的快照，并使用当前日期生成S3桶中的路径。这种方法能够确保快照文件被有序存储。

2. 构建导出任务参数

export_task_identifier = f"export-db-snapshot-{previous_date_str}"
source_arn = f"arn:aws:rds:region:account-id:snapshot:rds:db-instance-{previous_date_str}-snapshot"
s3_bucket_name = "your-s3-bucket-name"
s3_prefix = f"rds-export/{current_date}"
iam_role_arn = "arn:aws:iam::account-id:role/your-lambda-role"
export_only = ["your_table_name"]
kms_key_id = "your-kms-key-id"

在这里，我们设置了导出任务的标识符、源快照ARN、目标S3桶及路径、IAM角色、导出的数据表以及KMS密钥。每个参数的配置都对任务的执行至关重要。

3. 启动导出任务

response = rds_client.start_export_task(
    ExportTaskIdentifier=export_task_identifier,
    SourceArn=source_arn,
    S3BucketName=s3_bucket_name,
    S3Prefix=s3_prefix,
    IamRoleArn=iam_role_arn,
    ExportOnly=export_only,
    KmsKeyId=kms_key_id
)
print("Export Task Started Successfully:", response)

通过调用start_export_task方法，我们启动了导出任务，并将参数传递给AWS RDS。成功启动任务后，我们可以查看响应确认任务已正确执行。

4. 错误处理

1
2
3

except Exception as e:
    print("Error starting export task:", e)
    raise e

错误处理部分确保了在启动导出任务时如果发生异常，能够记录错误信息并抛出异常，方便后续排查。

总结：Lambda与RDS快照导出的无缝集成

通过AWS Lambda自动化导出RDS数据库快照，我们能够显著提升数据管理的效率。这种自动化不仅简化了操作流程，还减少了人为错误的风险，使得数据备份和存档变得更加可靠。

希望这个文章能帮助您实现数据库快照的自动化导出。

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/240914102425/
相关话题：https://www.cnsre.cn/tags/lambda/

深入探索 Aurora MySQL 配置及使用掌握关键参数与高可用性架构

Wenlong — Fri, 13 Sep 2024 10:24:10 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/240913102410/
相关话题：https://www.cnsre.cn/tags/aws/

Amazon Aurora 是 AWS 提供的一种高性能、高可用性的数据库解决方案，特别是在大型应用程序中表现尤为出色。今天，我们将通过实际实验深入了解 Aurora MySQL 的核心架构、容错能力，以及如何根据需求灵活配置参数。相信通过此次探讨，您将获得更多关于 Aurora 数据库的启示，并能自如应对实际工作中的挑战。

1. Aurora MySQL 的架构与工作原理

首先，Amazon Aurora MySQL 的架构相当独特。它由一个集群卷和多个数据库实例组成，集群卷跨越多个 AWS 可用区，这为数据的持久性和安全性提供了坚实的基础。Aurora 分为两类数据库实例：

主数据库实例：支持读写操作，是数据修改的主要入口。
Aurora 副本：仅支持读取操作，通过从主数据库实例分担读取负载来提高集群的性能。

我们通过实验发现，当主数据库实例出现问题时，Aurora 会自动将其副本提升为新的主实例，确保数据库的高可用性。这一过程几乎不需要手动干预，极大地提高了服务的稳定性。

实验：主实例自动故障转移

在实验中，我们模拟了主实例的故障。通过故意终止主实例，Aurora 迅速提升了一个副本为新的主实例，整个过程在不到 60 秒的时间内完成。这不仅展现了 Aurora 的快速响应能力，还验证了其在高可用性场景中的可靠性。

2. 了解 Aurora MySQL 的关键配置参数

在 Aurora MySQL 的配置过程中，某些关键参数会直接影响集群的性能与可用性。我们在实验中探索了这些参数的作用：

DB 引擎版本：Aurora 支持多个 MySQL 版本，目前最新的版本为 2.11.0（在部分地区已发布）。不同版本间可能存在兼容性差异，因此在选择时需特别注意。
复制设置：Aurora 允许最多 15 个副本，这些副本不仅提升了读取性能，还能在主实例故障时发挥关键作用。

实验：集群扩展与性能测试

为了验证 Aurora 在扩展方面的能力，我们向现有的集群中添加了多个副本，并测试了在高并发读取场景下的响应时间。结果表明，随着副本数量的增加，集群的读取吞吐量大幅提升，同时响应延迟显著降低。

这意味着，对于需要高并发读操作的应用程序而言，适当增加 Aurora 副本数量可以有效提升性能。

3. 容错能力与数据安全

Aurora 的容错设计体现在它的集群卷跨越多个可用区。当其中一个可用区出现故障时，其他可用区的数据副本能够立即接管，确保服务不中断。

实验：可用区故障模拟

我们模拟了某个可用区的故障，观察 Aurora 如何应对。实验中，Aurora 集群在不丢失任何数据的情况下，快速从其他可用区恢复服务。数据库的短暂中断时间约为几秒钟，几乎对应用程序没有明显影响。

这一实验再次证明了 Aurora 在数据安全和高可用性方面的卓越设计。

4. Aurora 终端节点类型

Aurora 数据库集群提供了多种终端节点，用于支持不同的操作需求：

集群终端节点：用于主实例的读写操作。
读取器终端节点：将读请求分配给多个副本，平衡读取负载。
实例终端节点：针对特定的数据库实例进行操作。

在日常操作中，正确使用这些终端节点能够显著提升数据库性能与管理的便利性。我们通过实验发现，使用读取器终端节点可以有效分散读取压力，特别是在大规模并发读取的场景下。

实验：终端节点的选择与负载分配

通过实验，我们向 Aurora 集群发出了大量并发请求，并通过读取器终端节点分配这些请求给不同的副本，结果读取延迟得到了极大的降低。这表明，通过合理利用不同类型的终端节点，我们能够有效提高数据库的响应速度。

结论

通过本次实验，我们深入理解了 Amazon Aurora MySQL 的关键架构和配置参数，并验证了其在高可用性、性能优化以及容错设计方面的卓越表现。Aurora 的自动故障转移机制、高效的副本管理和灵活的终端节点配置，使其成为企业级应用中极具吸引力的数据库解决方案。

在未来的工作中，您可以根据业务需求，灵活调整 Aurora 的配置，以充分发挥其潜力。如果您有更复杂的场景或特殊需求，建议深入研究 Aurora 文档，并结合实际环境进行更多实验。

参考资料

[1] Amazon Aurora 数据库集群
[2] Amazon Aurora MySQL 2 的数据库引擎更新
[3] Aurora 数据库集群的容错能力
[4] Aurora 终端节点的类型

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/240913102410/
相关话题：https://www.cnsre.cn/tags/aws/

如何在 AWS WAF 中为固定 URI 请求设置例外？

Wenlong — Tue, 10 Sep 2024 11:35:26 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/240910113525/
相关话题：https://www.cnsre.cn/tags/aws/

如何通过 AWS WAF 自定义规则处理固定 URI 请求例外

当我们在配置 AWS WAF（Web 应用程序防火墙）时，托管规则组能够保护我们的应用程序免受常见的安全威胁，如跨站脚本 (XSS) 和 SQL 注入 (SQLi)。但是，有时我们可能会遇到一些特殊需求，像是在特定的 URI 上允许某些请求通过，而不受这些托管规则的影响。那么，如何为固定 URI 添加请求例外呢？本文将为我们详细介绍如何通过自定义规则来实现这一需求。

什么是 AWS WAF 托管规则组？

AWS WAF 提供了一系列托管规则组，旨在帮助开发者快速应对常见的 Web 应用程序攻击，例如 XSS 和 SQLi。托管规则组的优势在于它们由 AWS 安全团队不断维护和更新，确保规则始终能应对最新的安全威胁。

不过，在某些情况下，默认的托管规则组可能会拦截一些合法请求。比如，当我们有一个上传图片的页面时，XSS 或 SQLi 规则组可能会误判请求内容，导致上传失败。这时，我们就需要为特定的 URI 设置例外。

如何为特定 URI 添加例外？

为特定 URI 添加例外有多种方法，以下是其中的几个常用方式：

1. 使用自定义规则

在托管规则组之前添加自定义规则是最直接的一种方式。我们可以创建一个自定义规则，允许这些特殊的 URI 通过，并将这个自定义规则放在托管规则组的前面。这样，当 WAF 检测到请求匹配自定义规则时，它将跳过后续规则的检查。

但是，这种方式有一个缺点：在匹配到自定义规则后，所有的托管规则都不再对该请求进行检查。这意味着，除了添加例外 URI 的规则外，其他任何与该 URI 相关的安全检查也会被跳过。

2. 使用 Scope-down Statement

另一种更灵活的方法是使用托管规则组中的 Scope-down Statement。这个选项允许我们缩小托管规则组的作用范围，从而仅在请求不匹配某些条件时（如特定 URI）执行规则检查。

操作步骤：

选择需要修改的托管规则组，例如 AWSManagedRulesCommonRuleSet 或 AWSManagedRulesSQLiRuleSet。
点击编辑规则组，并启用 Scope-down Statement。
设置匹配条件：选择 URI Path，并设置匹配方式，例如完全匹配、部分匹配或正则表达式匹配。
输入我们希望例外的 URI，例如 /picture/。

这样配置后，WAF 将只在请求的 URI 不匹配该字符串时才执行托管规则组的检查，从而为特定的 URI 添加例外。

3. 仅计数规则 (Count Mode)

如果我们希望暂时观察某些规则的效果，而不希望立即拦截请求，可以将某些规则设置为仅计数模式。具体操作是将托管规则组中的相关规则（如 CrossSiteScripting_BODY 或 SQLi_BODY）的动作改为 Count。这样，即使这些规则匹配到了请求，WAF 也只会记录日志而不拦截请求。

之后，我们可以根据日志中的信息创建自定义规则，确保只有特定的 URI 会绕过这些规则，而不影响其他安全检查。

示例操作

为了帮助我们更好地理解，以下是一个使用 Scope-down Statement 来为固定 URI 添加例外的配置示例。

假设我们希望为 /picture/ 路径添加 XSS 和 SQLi 规则的例外，具体步骤如下：

进入 AWS WAF 控制台，选择我们要修改的托管规则组，例如 AWSManagedRulesCommonRuleSet。
点击编辑该规则组，找到 Scope-down Statement 选项，并启用它。
选择 URI Path，并设置匹配方式为 Exactly matches string。
在 Search string 中输入 /picture/。

配置完成后，我们可以通过以下命令来验证效果：

# 测试URI例外
curl -X POST https://test-waf.cnsre.cn/picture/ -F "user='<script><alert>Hello></alert></script>'"
# 测试其他URI被拦截
curl -X POST https://test-waf.cnsre.cn/picture1 -F "user='<script><alert>Hello></alert></script>'"

在这个例子中，WAF 将放行 /picture/ 请求，而对 /picture1 进行拦截。

结论

通过自定义规则和 Scope-down Statement，我们可以为 AWS WAF 托管规则组添加灵活的例外处理，确保关键的业务流程不会受到不必要的影响，同时保持应用程序的安全性。

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/240910113525/
相关话题：https://www.cnsre.cn/tags/aws/

如何解决 Amazon EKS 中 Fargate 无法访问公网的问题

Wenlong — Mon, 09 Sep 2024 09:28:27 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/240909092827/
相关话题：https://www.cnsre.cn/tags/eks/

如何解决 Amazon EKS 中 Fargate 无法访问公网的问题

背景介绍

在使用 EKS + Fargate 创建服务的测试过程中，遇到了 Fargate 中的 Pod 无法访问公网的问题。该案例中，Fargate 和 EC2 实例使用了相同的子网配置，然而 Fargate Pod 无法访问公网，而 EC2 Pod 可以正常访问。本文将深入分析该问题的原因，并提供相应的解决方案。

案例描述

我们在 AWS 环境中配置了一个 EKS 集群，其中既包含 EC2 节点的 Pod，也包含 Fargate 节点的 Pod。EC2 节点的 Pod 可以正常访问公网，但 Fargate 节点的 Pod 却出现了无法解析域名、访问超时的情况。

关键问题

在我们尝试使用 Fargate Pod 访问公网时，使用 kubectl exec 进入 Fargate Pod 后，尝试执行 apt-get update 以更新系统包，但出现了如下错误：

`1`	`0% [Connecting to archive.ubuntu.com] [Connecting to security.ubuntu.com] ^C`

这表明 Fargate Pod 无法访问外部网络，而 EC2 节点的 Pod 则可以正常执行命令、连接公网。

分析与调查

经过 AWS 技术支持的深入分析，问题的根源在于 安全组配置。Fargate 使用的 Pod 默认通过 CoreDNS 解析域名，当我们使用 dig 命令解析域名时，返回了超时错误。这说明 Fargate Pod 的 DNS 请求未能正确处理。

在检查我们的 EC2 节点时，发现该节点的安全组仅放行了来自 Fargate 的 TCP 请求。然而，DNS 请求通常使用 UDP 协议，因此在 Fargate Pod 尝试进行 DNS 解析时，由于安全组未放行 UDP 流量，导致了超时。

解决方案

为了解决这一问题，AWS 技术支持建议修改 EC2 节点的安全组配置。通过放行来自 集群安全组 的所有流量，包括 TCP 和 UDP 请求，确保 Fargate Pod 能够正常进行 DNS 解析和公网访问。

步骤如下：

登录 AWS 控制台，进入 EC2 管理页面。
选择对应的 EC2 实例，并查看其附加的安全组。
修改安全组规则，确保放行来自 Fargate 的所有流量，特别是 UDP 53 端口，用于 DNS 请求。
保存更改后，重新测试 Fargate Pod 的公网访问能力。

结果验证

在修改安全组后，我们的 Fargate Pod 可以正常访问公网，使用 apt-get update 命令成功连接到外部源。这说明问题已彻底解决。

Fargate Pod 成功连接公网输出

root@awslinux-fargate-pod:/# apt-get update
Hit:1 http://archive.ubuntu.com/ubuntu focal InRelease
Get:2 http://security.ubuntu.com/ubuntu focal-security InRelease [114 kB]
Fetched 114 kB in 1s (150 kB/s)
Reading package lists... Done

通过这些配置修改，Fargate Pod 的网络访问问题得到了彻底解决，我们的生产环境也恢复了正常运行。

常见问题与预防

为什么 Fargate 和 EC2 的网络行为不同？

Fargate 和 EC2 节点虽然可以共享同一个子网，但它们在网络层面的实现存在差异。Fargate 使用 AWS 提供的托管网络，因此其默认行为与 EC2 节点有所不同。在配置安全组时，特别需要注意两者的网络规则是否兼容。

如何避免类似问题？

为了避免类似的网络问题，建议在配置 EKS 集群时，仔细检查所有节点（包括 Fargate 和 EC2）的 安全组配置 和 网络规则。确保放行集群内部所需的所有流量，尤其是 UDP 53 端口，以支持 DNS 请求的正常运行。

注意：
为了能够保证Fargate 和EC2 node 的通信，尽量打通集群安全组，和 EC2 node 的安全组的通讯问题。即 EC2 node 安全组全部放行可以访问集群安全组，集群安全组全部放行可以访问EC2 node。

结论

通过本文，我们深入探讨了 Amazon EKS 环境中 Fargate Pod 无法访问公网的问题及其解决方案。这一问题主要是由于 安全组未放行 UDP 流量 导致的，通过适当的安全组配置调整，问题得以顺利解决。如果您在使用 AWS EKS 时遇到类似的网络问题，建议从安全组配置入手，确保所有必要的流量得到了正确放行。

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/240909092827/
相关话题：https://www.cnsre.cn/tags/eks/

实现Kubernetes跨Namespace Service访问的最佳实践

Wenlong — Fri, 06 Sep 2024 08:57:14 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/240906085714/
相关话题：https://www.cnsre.cn/tags/kubernetes/

实现Kubernetes跨Namespace Service访问的最佳实践

在Kubernetes运维场景中，经常会遇到跨Namespace（名称空间）的Service访问需求。为了实现不同Namespace下的Pod能够通过Service名称进行跨Namespace访问，我们可以利用Kubernetes的ExternalName类型Service来解决这个问题。

在本文中，我将展示如何配置和实现这种跨Namespace的通信。我们将通过一个完整的示例来详细说明配置过程和关键步骤。

1. 场景需求

假设我们有两个不同Namespace下的两个Service和Pod：

Namespace A：ServiceA (PodA)
Namespace B：ServiceB (PodB)

我们希望实现PodA通过ServiceB的名称进行通信，而不是通过Service的IP地址。由于Service的IP地址可能会在重启时发生变化，而Service的名称则保持不变，这样可以确保通信的稳定性。

2. 创建Service和Pod

首先，我们需要为两个Namespace分别创建对应的Pod和Service。

在`myns` Namespace中创建Pod和Service

apiVersion: v1
kind: Namespace
metadata:
  name: myns
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deploy1
  namespace: myns
spec:
  replicas: 2
  selector:
    matchLabels:
      app: myapp
      release: v1
  template:
    metadata:
      labels:
        app: myapp
        release: v1
    spec:
      containers:
      - name: myapp
        image: registry.cn-beijing.aliyuncs.com/google_registry/myapp:v1
        ports:
        - name: http
          containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: myapp-clusterip1
  namespace: myns
spec:
  type: ClusterIP
  selector:
    app: myapp
    release: v1
  ports:
  - name: http
    port: 80
    targetPort: 80

在`mytest` Namespace中创建Pod和Service

apiVersion: v1
kind: Namespace
metadata:
  name: mytest
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deploy2
  namespace: mytest
spec:
  replicas: 2
  selector:
    matchLabels:
      app: myapp
      release: v2
  template:
    metadata:
      labels:
        app: myapp
        release: v2
    spec:
      containers:
      - name: myapp
        image: registry.cn-beijing.aliyuncs.com/google_registry/myapp:v2
        ports:
        - name: http
          containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: myapp-clusterip2
  namespace: mytest
spec:
  type: ClusterIP
  selector:
    app: myapp
    release: v2
  ports:
  - name: http
    port: 80
    targetPort: 80

3. 检查创建结果

运行以下命令来应用这些YAML文件并检查Service和Pod的状态：

kubectl apply -f deply_service_myns.yaml
kubectl apply -f deply_service_mytest.yaml

kubectl get svc -n myns -o wide
kubectl get svc -n mytest -o wide
kubectl get pod -A -o wide

4. 跨Namespace Service通信问题

在默认情况下，PodA无法通过Service名称直接访问Namespace B中的Service。下面是PodA尝试访问PodB的日志输出：

1
2
3

# kubectl exec -it -n myns myapp-deploy1-36ds6g873r8-asy2us sh
/ # ping myapp-clusterip2
ping: bad address 'myapp-clusterip2'

这是因为默认的Kubernetes DNS解析只支持在同一Namespace内解析Service名称。

5. 解决方案：使用`ExternalName`类型的Service

为了解决这个问题，我们可以在每个Namespace中创建一个ExternalName类型的Service。ExternalName允许通过指定的FQDN（完全限定域名）来指向其他Namespace中的Service。

以下是实现跨Namespace通信的Service配置：

在`myns` Namespace中创建`ExternalName` Service

apiVersion: v1
kind: Service
metadata:
  name: myapp-clusterip1-externalname
  namespace: myns
spec:
  type: ExternalName
  externalName: myapp-clusterip2.mytest.svc.cluster.local
  ports:
  - name: http
    port: 80
    targetPort: 80

在`mytest` Namespace中创建`ExternalName` Service

apiVersion: v1
kind: Service
metadata:
  name: myapp-clusterip2-externalname
  namespace: mytest
spec:
  type: ExternalName
  externalName: myapp-clusterip1.myns.svc.cluster.local
  ports:
  - name: http
    port: 80
    targetPort: 80

运行以下命令来应用这些新的Service配置：

`1`	`kubectl apply -f svc_ExternalName_visit.yaml`

6. 验证跨Namespace通信

现在我们可以再次尝试从PodA访问PodB，应该可以成功解析并进行通信：

1
2

kubectl exec -it -n myns myapp-deploy1-36ds6g873r8-asy2us sh
/ # ping myapp-clusterip2.mytest.svc.cluster.local

这样，PodA就可以通过Service名称访问不同Namespace中的PodB了。

7. 总结

通过使用Kubernetes的ExternalName类型Service，我们成功实现了跨Namespace的Service名称解析和通信。此方法避免了直接使用IP地址通信的局限性，确保了即使Service的IP地址发生变化，通信依然可以通过名称进行。

这种跨Namespace通信的场景在多租户、多环境隔离的Kubernetes集群中尤为常见。如果你的集群架构中需要不同Namespace之间的Service互访，ExternalName是一个有效的解决方案。

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/240906085714/
相关话题：https://www.cnsre.cn/tags/kubernetes/

阿里云申请发布社区镜像权限

Wenlong — Fri, 08 Dec 2023 09:44:11 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/231208094411/
相关话题：https://www.cnsre.cn/tags/阿里云/

申请前须知

社区镜像前，请先了解以下注意事项：

只有通过企业认证的才可以申请使用社区镜像发布功能。
加密镜像不允许发布为社区镜像。
社区镜像完全公开，在镜像所属地域下，所有的阿里云账号均可使用。
社区镜像不支持共享、导出与复制。

申请流程

申请企业认证

因为只有通过企业认证的用户才有权限申请发布社区镜像，所以要先进行社区认证。

本文主要以申请社区镜像发布权限为主，不再介绍企业认证方法。没有社区认证的用户可以参考链接阿里云企业认证

创建自定义镜像

在申请发布社区镜像之前，首先要把镜像制作好。

发布社区镜像的镜像来源主要有控制台创建自定义镜像、OpenAPI、镜像构建Image Builder、Packer等。本地以控制台创建自动以镜像为例。

登录到控制台，按照下图进行操作。进行镜像的制作。

点击创建自定义镜像后，出现如下界面

点击创建后，需要等待一段时间。创建时间主要看磁盘和数据量的大小决定的。

收集镜像信息

创建完自动以镜像后，需要收集一些镜像的信息，以备申请权限时使用。

具体信息如下：

**镜像名称：**Wrodpress
**操作系统及版本：**CentOS 7.9 64位 UEFI版
镜像大小： 40GB
**应用场景：**发布的社区镜像将应用于CloudIaC模板中,用来创建对应的云服务。后续还会推出更多应用和镜像。
**如何引流、用户群：**通过官网CloudIaC模板引流使用社区镜像。主要用户群是学生和高校。
**计划发布、更新：**在多个地域发布社区镜像,并长期更新维护。
**镜像制作方式：**通过控制台创建自定义镜像的方式制作镜像。

提交工单申请权限

准备完以上信息后，就可以提工单申请了。我这边也给大家准备了申请话术供大家参考：

尊敬的阿里云支持团队，

我云霁科技的账户管理员雪文龙，我代表杭州云霁科技有限公司。
我们近期开发了一款基于CentOS 7.9 定制了WordPress的系统镜像，经过内部测试和优化，我们相信这个镜像对阿里云社区的用户会有很大的价值。
为了分享我们的工作，并让更多的用户受益，我们希望能够将这个自定义系统镜像发布到阿里云社区镜像中。在此，我们诚恳地申请获得发布镜像的权限。
以下是有关我们自定义系统镜像的一些基本信息：
1. 发布者认证名称： Yunjikeji Ampere Computing
2. 镜像名称：Wrodpress
3. 操作系统及版本：CentOS 7.9 64位 UEFI版
4. 镜像大小： 40GB
5. 应用场景：发布的社区镜像将应用于CloudIaC模板中,用来创建对应的云服务。后续还会推出更多应用和镜像。
6. 如何引流、用户群：通过官网CloudIaC模板引流使用社区镜像。主要用户群是学生和高校。 
7. 计划发布、更新：在多个地域发布社区镜像,并长期更新维护。
8. 镜像制作方式：通过控制台创建自定义镜像的方式制作镜像。

我们相信这个系统镜像将为阿里云社区的用户提供更丰富的选择，并有助于推动云计算社区的发展。
我们理解阿里云社区对镜像的质量和安全性有严格的要求，因此我们已经采取了一系列措施来确保我们的镜像符合最高标准。
在此，我们真诚地期待能够得到您的支持和批准，以便我们的系统镜像能够为更多的用户服务。
谢谢您的时间和考虑。

针对提交工单申请权限的一些疑问：

提交工单申请权限审核的时间是多久?
- 申请权限的审核时间没有的到具体的回复。不过在催工单的情况下，我是从申请到得到权限用了24个小时。
提交工单申请权限审核的流程是什么?
- 申请权限的流程。准备申请发布镜像的材料 – 提交申请工单 – 审核团队核对提交申请材料 – 补充申请材料（如果需要）– 审核镜像 – 开通权限。因为没有公布具体的审核流程，但是从沟通上我猜想可以这样去理解
有没有一些快捷的方式可以尽快通过审核？
- 有的。值得一提的是，在我后续申请到了权限以后，我也可以发布没有进行审核的镜像发布到社区镜像中。所以大家在申请社区镜像权限的时候，可以选择申请一个尽量符合规则标准的镜像去申请。

发布社区镜像

经历24小时的来回拉扯。得到了回复 您好 : 后台已经审核完毕，您在配置发布镜像看下呢。

拿到权限。发布测试。

进入镜像功能页面。
1. 登录ECS管理控制台。
2. 在左侧导航栏，选择实例与镜像 > 镜像。
3. 在顶部菜单栏左上角处，选择地域。
在自定义镜像页签，找到待发布为社区镜像的可用自定义镜像，然后在操作列选择... >发布为社区镜像。
在发布为社区镜像对话框，完成社区镜像的发布。

发布成功后，您可以在镜像页面，单击社区镜像页签，查看已发布的社区镜像信息。

参考链接

https://help.aliyun.com/zh/ecs/user-guide/overview-12

https://help.aliyun.com/zh/pnp/l6821168?spm=5176.22414175.sslink.1.638a753bYT0ivM

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/postsid/
相关话题：https://www.cnsre.cn/tags/阿里云/

如何使用 Lambda 自动添加CloudWatch所有实例磁盘告警及 SNS 通知

Wenlong — Sat, 06 May 2023 14:25:09 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/230506425079/
相关话题：https://www.cnsre.cn/tags/lambda/

利用Lambda轻松实现EC2实例监控

最近新增了一些服务器，因为每个服务器的基础监控都是要做的。我就想，如何能够快速便捷的方式把这些基础指标都监控上呢？本文将详细介绍如何通过Lambda自动为所有EC2实例添加CloudWatch磁盘告警,并在磁盘利用率超过阈值时,通过SNS主题发送通知。

准备工作

在开始前,我们需要准备:

AWS账号:开通一个AWS账号。
SNS主题:在SNS上创建一个主题,并添加订阅者。订阅方式可以是邮件、短信等。
VPC ID:登录VPC控制台获取VPC ID。
Lambda：需要创建一个Lambda。

创建SNS主题

接下来,我们需要在AWS SNS上创建一个主题,并将订阅者添加到主题中。这些订阅者将会接收磁盘使用超过阈值时的通知。我们可以选择电子邮件、短信等通知方式。

登录到 Amazon SNS 控制台。

单击左侧面板上的“主题”,然后单击“创建主题”。

输入主题名称和主题显示名称,单击“创建主题”。

在主题页面上,单击“订阅”,选择希望接收通知的通知方式。

根据选定的订阅类型输入相关信息,单击“创建订阅”。
在主题页面上,您将看到已创建的订阅。
举个例子,如果我们选择“邮件”作为订阅方式:
在“电子邮件订阅”下,输入接收通知的电子邮件地址。
单击“创建订阅”。
您应会收到一封来自AWS通知的验证电子邮件。请按照电子邮件中的说明进行验证。
一旦验证通过,该订阅将变为“已验证”状态。

现在,当CloudWatch告警触发并调用SNS主题时,验证的电子邮件地址将收到有关警报的电子邮件通知。我们也可以添加多个订阅以接收通过不同渠道的通知,例如电子邮件、短信等。添加订阅者后,我们可以在SNS主题的“概述”页查看订阅的详细信息和状态。在测试Lambda函数时,这有助于确保订阅设置正确和通知能正常发送。

创建Lambda函数

接下来,我们可以在Lambda控制台创建一个新的Lambda函数。

访问 Amazon Lambda 控制台,点击“创建函数”。

选择“从头开始” ,输入函数名称,如“create_cloudwatch_alarm_for_ec2_disk_usage”。
选择Python作为运行环境,选择创建具有基本 Lambda 权限的新角色。
点击“创建函数”。

编写Lambda函数代码

代码我已经写好了，各位大佬收好。代码功能是为所有EC2实例设置CloudWatch磁盘告警,当磁盘利用率超过阈值时,通过SNS主题发送通知。

连接EC2客户端。
获取VPC中运行的EC2实例列表。
遍历实例创建CloudWatch磁盘使用百分比告警。默认阈值是80%。
告警触发SNS主题“you_sns_arn”。

将下面代码复制后进行部分修改。然后替换掉原有代码后，然后保存并部署。

下面是具体代码内容：

'''
Author       : Wenlong Xue 
Date         : 2023-02-27 13:35
LastEditors  : Wenlong Xue 
LastEditTime : 2023-02-27 17:52
Description  : 为 VPC 中的 EC2 实例创建磁盘使用百分比的 CloudWatch 告警，并在磁盘使用超过阈值时发送通知到 SNS 主题
'''
import boto3

def lambda_handler(event, context):
    
    # 连接到 EC2 客户端
    ec2 = boto3.client('ec2')
    
    # 获取 VPC 中运行中的实例列表
    response = ec2.describe_instances(
        Filters=[
            {
                'Name': 'vpc-id',
                'Values': ['vpc-xxxxxx']      # 修改VPC ID
            },
            {
                'Name': 'instance-state-name',
                'Values': ['running']
            }
        ]
    )
    
    # 遍历实例并为磁盘使用百分比创建 CloudWatch 告警
    for reservation in response['Reservations']:
        for instance in reservation['Instances']:
            
            # 获取实例 ID 和 Name 标签
            instance_id = instance['InstanceId']
            instance_name = ''
            for tag in instance['Tags']:
                if tag['Key'] == 'Name':
                    instance_name = tag['Value']
                    break
            
            # 创建磁盘使用百分比的 CloudWatch 告警
            cloudwatch = boto3.client('cloudwatch')
            cloudwatch.put_metric_alarm(
                AlarmName='{}-磁盘使用百分比'.format(instance_name),
                AlarmDescription='{} - 磁盘使用百分比'.format(instance_name),
                ActionsEnabled=True,
                AlarmActions=['you_sns_arn'],   # 修改sns主题,如:arn:aws-cn:sns:cn-north-1:xxxxx:HighDiskUsed
                MetricName='disk_used_percent', # 根据情况修改
                Namespace='CWAgent',            # 根据情况修改
                Dimensions=[
                    {
                        'Name': 'InstanceId',
                        'Value': instance_id
                    }
                ],
                Statistic='Maximum',
                Period=300,
                EvaluationPeriods=1,
                Threshold=80.0,
                ComparisonOperator='GreaterThanOrEqualToThreshold'
            )

给IAM角色添加权限

因为创建具有基本 Lambda 权限的新角色的权限并不完整，所以我们要把代码中所要用到的权限给到这个新角色。

首先,Lambda中找到这个觉得然后给他添加对应的权限。

找到创建的Lambda 函数。
选择函数汇总的配置–权限。
找到执行角色，并点击角色名称连接。

点击添加权限，选择附加策略。
添加 CloudWatchFullAccess 和 AmazonEC2ReadOnlyAccess 权限

最后权限如下：

注意

⚠️ 若提示确少什么权限就补充什么权限。

测试函数

现在,我们已经创建Lambda函数和SNS主题,并将订阅者添加到主题。我们可以测试Lambda函数功能。

我们可以手动运行测试来观察 CloudWatch告警项有没有被添加。
我们也可以进行添加触发器。如：固定时间段运行一次，来遍历新加的服务器。然后添加告警项。

常见问题及解决方案

Q1: 没收到SNS通知怎么办?
A1: 确认订阅邮箱是否正确。检查AWS账号是否有权限向SNS发送通知。
Q2: 如何修改磁盘使用阈值?
A2: 编辑Lambda函数代码,更改"Threshold"的值。
Q3: CloudWatch的告警项中显示数据不足怎么办?
A3: 查看CloudWatch中原本磁盘的指标名称，并修改Lambda函数代码对应的值：MetricName=‘disk_used_percent’；Namespace=‘CWAgent’

参考资料

AWS Lambda文档: https://docs.aws.amazon.com/lambda/
AWS CloudWatch文档: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/
AWS SNS文档: https://docs.aws.amazon.com/sns/index.html

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/230506425079/
相关话题：https://www.cnsre.cn/tags/lambda/

Lambda函数检查S3文件夹是否存在

Wenlong — Mon, 10 Apr 2023 16:59:07 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/230410659053/
相关话题：https://www.cnsre.cn/tags/lambda/

Lambda函数检查S3文件夹是否存在

作为 AWS 中最常用的对象存储服务，S3 可以用于存储各种类型的文件，包括网站文件、媒体文件、备份文件等等。在 S3 中存储的文件可以通过不同的方式访问，例如在 Web 应用程序中、通过移动应用程序或直接使用 AWS SDK 访问等。

在进行 S3 存储时，如果我们需要将存储的日志同步到另一个桶或区域中，则可以使用 AWS 的 S3 日志同步任务功能。通过将日志同步到其他存储桶或区域中，我们可以更方便地对日志进行分析、监控和管理。

但是，如果 S3 日志同步任务出现故障，我们可能无法及时获取相关的日志信息。因此，为了确保日志同步任务的正常运行，我们需要对任务进行监控。在本文中，我们将介绍如何使用 AWS Lambda 监控 S3 日志同步任务。

介绍

AWS Lambda 是一种无服务器计算服务，可使您在云中运行代码，而无需自己管理服务器。通过使用 Lambda，您可以将代码上传到云中，然后 Lambda 会根据需要自动扩展和缩减计算资源，以满足您的应用程序的请求。Lambda 还支持许多编程语言和库，使您能够编写功能强大的应用程序和服务。

在本文中，我们将使用 Lambda 编写一个函数，该函数将定期检查 S3 存储桶中的文件夹是否存在。如果不存在任何文件夹，则 Lambda 将向指定的 SNS 主题发送一条消息，以便管理员可以及时采取措施。通过使用 Lambda 监控 S3 存储桶中的文件夹，我们可以确保日志同步任务的正常运行。

1. 准备工作

在开始之前，我们需要先准备好以下工作：

一个S3桶，用于存储我们要检查的文件夹。
一个SNS主题，用于发送消息提醒。

2. 创建Lambda函数

在AWS控制台上创建一个Python Lambda函数，名称为s3-folder-exist-checker，并使用以下代码：

import boto3
from datetime import datetime, timedelta
from dateutil import tz

def lambda_handler(event, context):
    print('Lambda 函数已启动.')
    
    s3 = boto3.resource('s3')
    bucket_name = 'my_s3_bucket_name'
    local_tz = tz.gettz('Asia/Shanghai')
    now = datetime.now()
    date_prefix = now.strftime('%Y/%m/%d/')
    
    folder_prefixes = ['my_prefixes/' + date_prefix, 'my_prefixes/' + date_prefix, 'RGC-Prod-3in1oven/' + date_prefix]
    folder_prefixes = [prefix + '/' if not prefix.endswith('/') else prefix for prefix in folder_prefixes]  # 确保每个前缀以斜杠结尾
    
    print('正在检查以下 S3 文件夹：', folder_prefixes)
    
    sns = boto3.client('sns')
    topic_arn = 'arn:aws-cn:sns:cn-north-1:1234567890:s3-logs-monitoring'
    
    for prefix in folder_prefixes:
        resp = s3.meta.client.list_objects_v2(Bucket=bucket_name, Prefix=prefix, Delimiter='/')
        subfolders = [p['Prefix'] for p in resp.get('CommonPrefixes', [])]
    
        if len(subfolders) > 0:
            print(f"子文件夹 '{prefix}' 存在:")
            for folder in subfolders:
                print(f"发现子文件夹: {folder}")
        else:
            message = f"S3桶'{bucket_name}中'{prefix}'下不存在新增文件夹,即日志同步S3桶任务失败.请检查.'"
            sns.publish(TopicArn=topic_arn, Message=message)
            print(f"已发送 SNS 消息: {message}")
        
    print('Lambda 函数已完成.')
    
    return {
        'statusCode': 200,
        'body': 'S3 文件夹存在性检查已完成.'
    }

接下来是对 Lambda 函数中的一些细节进行讲解。首先，我们定义了 S3 的资源，并且指定了 S3 桶的名称：

s3 = boto3.resource('s3')
bucket_name = 'my_bucket_name'

接着，我们获取当前的时间，并且根据当前时间生成一个目录前缀。我们使用 dateutil 模块中的 tz.gettz 函数来获取一个本地的时区信息。为了确保时区的准确性，我们建议在使用 Lambda 函数时，显式地设置时区信息：

local_tz = tz.gettz('Asia/Shanghai')
now = datetime.now(local_tz)
date_prefix = now.strftime('%Y/%m/%d/')

在 Lambda 函数中，我们使用了 list_objects_v2 方法来列举指定的文件夹。具体来说，我们使用了 CommonPrefixes 参数，该参数可以返回指定前缀下的子文件夹列表。如果返回的子文件夹列表为空，则说明指定的文件夹不存在。如果子文件夹列表不为空，则说明文件夹存在，并且我们可以将每个子文件夹的路径打印出来：

resp = s3.meta.client.list_objects_v2(Bucket=bucket_name, Prefix=prefix, Delimiter='/')
subfolders = [p['Prefix'] for p in resp.get('CommonPrefixes', [])]

if len(subfolders) > 0:
    print(f"子文件夹 '{prefix}' 存在:")
    for folder in subfolders:
        print(f"发现子文件夹: {folder}")

如果子文件夹列表为空，则说明文件夹不存在。在这种情况下，我们可以使用 SNS 服务发送一条消息来通知管理员：

if len(subfolders) == 0:
    message = f"S3桶'{bucket_name}中'{prefix}'下不存在新增文件夹,即日志同步S3桶任务失败.请检查.'"
    sns.publish(TopicArn=topic_arn, Message=message)
    print(f"已发送 SNS 消息: {message}")

最后，我们返回了一个包含状态码和消息的字典，以便可以在 Lambda 函数执行过程中监控执行状态：

return {
    'statusCode': 200,
    'body': 'S3 文件夹存在性检查已完成.'
}

确保您的 Lambda 函数有权限访问 S3 和 SNS
在 AWS Lambda 控制台中，创建一个新的 Lambda 函数。在函数代码中将 Python 代码粘贴到代码编辑器中。请确保您选择了正确的运行时环境，并设置以下环境变量：
- BUCKET_NAME：您的 S3 桶名称
- SNS_TOPIC_ARN：SNS 主题的 ARN
配置 Lambda 函数的基本设置和高级设置，包括内存和超时。
在 Lambda 控制台中，测试 Lambda 函数，以确保 Lambda 函数能够访问 S3 桶和 SNS 主题。为了测试该函数，您可以创建一个测试事件，该事件需要一个空的 JSON 对象，例如：
最后，您需要在 Amazon CloudWatch 中设置 CloudWatch Events 规则以定期触发 Lambda 函数。这样您的 Lambda 函数就能在您预定的时间检查 S3 文件夹是否存在并发送通知。

总结

在这篇文章中，我们介绍了一个使用 AWS Lambda、S3 和 SNS 的自动化任务，该任务定期检查 S3 文件夹是否存在并发送通知。我们解释了如何编写 Python 代码来实现此任务，并提供了一个详细的代码示例。我们还介绍了如何在 AWS Lambda 和 Amazon SNS 控制台上配置 Lambda 函数和 SNS 主题，并在 Amazon CloudWatch 中创建定期触发器来触发 Lambda 函数。最后，我们提供了一些最佳实践和注意事项，以确保您的 Lambda 函数和 SNS 主题能够正常工作。

希望这篇文章对您有所帮助！如果您有任何疑问或建议，请在下面的评论区留言。

参考文献

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/230410659053/
相关话题：https://www.cnsre.cn/tags/lambda/

AWS 中的另外一种远程工具 AWS Session Manager

Wenlong — Sun, 29 Jan 2023 11:26:15 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/230129126154/
相关话题：https://www.cnsre.cn/tags/aws/

背景需求

因为项目的安全性。为了避免项目的服务器暴露在公网中。很多时候我们会使用跳板机或者是一些三方的远程工具，来进行一些安全性比较高的方式来进行远程项目的服务器，但是往往越安全的方式就越麻烦。那有没有一种既安全，有便捷的连接方式呢？当然有，今天就介绍下AWS Session Manager。

前置需求

一台 EC2 服务器（需要开启 SSM 远程服务并分配权限）
一个 AWS 账户

安装配置 SSM Agent

在 Amazon Linux 2 中安装SSM Agent

x86_64

`1`	`sudo yum install -y https://s3.amazonaws.com/ec2-downloads-windows/SSMAgent/latest/linux_amd64/amazon-ssm-agent.rpm`

ARM64

`1`	`sudo yum install -y https://s3.amazonaws.com/ec2-downloads-windows/SSMAgent/latest/linux_arm64/amazon-ssm-agent.rpm`

在 CentOS 7.x 上安装 SSM Agent

x86_64

`1`	`sudo yum install -y https://s3.amazonaws.com/ec2-downloads-windows/SSMAgent/latest/linux_amd64/amazon-ssm-agent.rpm`

ARM64

`1`	`sudo yum install -y https://s3.amazonaws.com/ec2-downloads-windows/SSMAgent/latest/linux_arm64/amazon-ssm-agent.rpm`

启动服务并设置为开机启动

1
2

sudo systemctl status amazon-ssm-agent
sudo systemctl enable amazon-ssm-agent

如其他系统安装请参考在适用于 Linux 的 EC2 实例上手动安装 SSM Agent

给 EC2 分配对应权限

在角色管理中选择创建角色。
如下如图所示选择对应选项。

搜索AmazonSSMFullAccess 选择下一步

填入角色名称，然后创建角色

在 AWS EC2 控制台中找到对应的服务器，然后点击操作``安全 修改IAM角色

在框内搜索刚才创建的角色名称。然后确定选择。

AWS 中的远程链接方式 Session Manager

安装完以后可以在AWS 中我们可以直接通过控制台去链接 Linux 服务器，如下图。在选中实例以后在右上角中选择连接。然后再次进行远程登录服务。

如遇到无法远程的情况请按照下面的方法将安装ssm服务。

在 SSM 中进行远程链接

在控制台 Amazon Systems Manager 中选择 Session Manager

选择启动会话。

选择对应的实例然后点击启动会话。

然后就进入到了系统界面。

如何通过IAM让不同的 aws 用户拥有不同的远程服务器权限？下篇文章将会介绍 Session Manager 的进阶用法

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/230129126154/
相关话题：https://www.cnsre.cn/tags/aws/

k3s 证书过期修改

Wenlong — Wed, 07 Dec 2022 11:16:00 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/221207116004/
相关话题：https://www.cnsre.cn/tags/k3s/

去年双十一买的服务器，但是创建了 K3S 集群。今天登录的时候发现出现了以下错误。简单记录下。

故障现象

登录服务器执行相关命令出现以下错误

1
2

[root@k3s-master ~]# kubectl get  pods
error: You must be logged in to the server (Unauthorized)

执行 doker 命令判断大概问题

1
2

[root@k3s-master ~]#  docker run -it ubuntu  /bin/echo "cnsre"
cnsre

docker 命令可以执行那大概率应该是 k3s 的问题,查看 k3s 服务日志

1
2

[root@k3s-master ~]# journalctl -r -u k3s
1466 authentication.go:63] "Unable to authenticate the request" err="[x509: certificate has expired or is not yet valid: current time

发现有以上错误，那确定是证书的问题了。

解决方法

对于K3S 来说解决证书的问题其实很简单。
可以通过重启K3S 服务的来解决问题

`1`	`sudo systemctl restart k3s`

验证

执行命令验证问题

[root@k3s-master ~]# kubectl get  node
NAME         STATUS     ROLES                  AGE    VERSION
k3s-node1    Ready      <none>                 370d   v1.21.5+k3s2
k3s-node2    Ready      <none>                 370d   v1.21.5+k3s2
k3s-node3    Ready      <none>                 370d   v1.21.5+k3s2
k3s-master   Ready      control-plane,master   370d   v1.21.5+k3s2

问题解决。

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/221207116004/
相关话题：https://www.cnsre.cn/tags/k3s/

使用 Lambda 函数将 CloudWatch Log 中的日志归档到 S3 桶中

Wenlong — Tue, 06 Dec 2022 11:48:12 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/221205544069/
相关话题：https://www.cnsre.cn/tags/aws/

躺了好久，诈尸了。因为换了工作，所以比较忙一直没有时间去更新博客的内容（主要还是因为懒🤔）

话不多说直接上干货。

需求背景

最近在看费用的时候发现有很大一部分费用都是 cloudwatch log中存储了大量的数据，是因为ec2 将日志传输到了存储到了cloudwatch中。这个存储的多的查询日志的时候收费特别的高。另外一个是因为数据分析用途，大数据分析的同事如果想那到数据的话，还是存储在 S3 中是比较划算和方便的，一个是拿取数据比较方便，另外一个是S3 可以最归档存储，后面的大量数据可以分层储存，以此来降低费用。
如果你也想将你的cloudwatch 中日志组中的日志存储到S3中的话可以参考下这篇文章。

前置条件

创建一个 S3 桶，并修改权限
创建 lambda 函数
有一个Cloudwatch 日志组并且有一天以上的日志
给 lambda分配所需的权限

创建 S3 桶并修改权限

国内S3桶权限配置

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "logs.cn-north-1.amazonaws.com.cn"
            },
            "Action": "s3:GetBucketAcl",
            "Resource": "arn:aws-cn:s3:::<bucket name>"
        },
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "logs.cn-north-1.amazonaws.com.cn"
            },
            "Action": "s3:PutObject",
            "Resource": "arn:aws-cn:s3:::<bucket name>/*",
            "Condition": {
                "StringEquals": {
                    "s3:x-amz-acl": "bucket-owner-full-control"
                }
            }
        }
    ]
}

国外S3桶权限配置

{
    "Version": "2012-10-17",
    "Statement": [
      {
          "Action": "s3:GetBucketAcl",
          "Effect": "Allow",
          "Resource": "arn:aws:s3:::<bucket name>",
          "Principal": { "Service": "logs.us-west-2.amazonaws.com" }
      },
      {
          "Action": "s3:PutObject" ,
          "Effect": "Allow",
          "Resource": "arn:aws:s3:::<bucket name>*",
          "Condition": { "StringEquals": { "s3:x-amz-acl": "bucket-owner-full-control" } },
          "Principal": { "Service": "logs.us-west-2.amazonaws.com" }
      }
    ]
}

S3 桶权限文档链接

创建 lambda 函数

创建 lambda

import boto3
import logging
import time
import datetime
import json

logger = logging.getLogger()
logger.setLevel(logging.INFO)

def export_s3_logs(bucket_name, log_group_name, log_stream_name, days_of_logs=1, timeout=1000):
    '''
    today = datetime.datetime.combine(datetime.datetime.utcnow(), datetime.datetime.min.time())
    day_end = today
    day_start = today - datetime.timedelta(days=days_of_logs)
    '''
    today = datetime.datetime.combine(datetime.datetime.utcnow() + datetime.timedelta(hours=8),
                                      datetime.datetime.min.time()) # UTC+8 

    day_end = today - datetime.timedelta(hours=8) # UTC
    day_start = today - datetime.timedelta(days=days_of_logs, hours=8) # UTC    
   
    #print(day_start)
    ts_start = '{0:.0f}'.format(((day_start - datetime.datetime(1970, 1, 1)).total_seconds())*1000)
    ts_end = '{0:.0f}'.format(((day_end - datetime.datetime(1970, 1, 1)).total_seconds())*1000)
    the_date = '/'.join([str(today.year), '0'+str(today.month)[-2:], '0'+str(today.day)[-2:]]) 
    #folder_name = '/'.join([log_group_name, log_stream_name, the_date])
    folder_name = '/'.join([log_group_name,the_date])
    client = boto3.client('logs')
    
    #print (ts_start, ts_end)#, day_start, day_end,the_date
    
    task_id = client.create_export_task(
        logGroupName=log_group_name,
        #logStreamNamePrefix=log_stream_name,
        fromTime=int(ts_start),
        to=int(ts_end),
        destination=bucket_name,
        destinationPrefix=folder_name
    )['taskId']

    i = 1
    while i<timeout:
        response = client.describe_export_tasks(
            taskId=task_id
        )

        status = response['exportTasks'][0]['status']
        if status == 'COMPLETED':
            result = True
            break
        elif status != 'RUNNING':
            result = False
            break
        i += 1
        time.sleep(interval)
    
    return result

def lambda_handler(event, context):
    region = 'cn-northwest-1' # 日志组所在区域
    bucket_name = '<bucket name>' #同区域内的S3桶名称
    log_group_name = '<log group name>' #日志组名称
    log_stream_name = '1' #默认即可
    log_export_days = 1   #默认即可
    export_s3_logs(bucket_name, log_group_name, log_stream_name, log_export_days)

给 lambda 分配权限

AmazonS3的读写权限
CloudWatchLogsFullAccess

验证桶内的文件

最后会以日期的目录将日志归档起来，以方便日后对归档文件进行梳理。

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/221205544069/
相关话题：https://www.cnsre.cn/tags/aws/

eks使用efs dynamic provisioning 创建非root容器提示 Operation not permitted

Wenlong — Tue, 25 Jan 2022 14:50:14 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/220125450139/
相关话题：https://www.cnsre.cn/tags/eks/

前言

之前在 aws 中创建了 eks，在数据存储这一块中，我选择了使用 AWS 的 EFS 具体部署配置参考Amazon EKS 中 EFS 持久性存储。文章中的动态供给是 AWS 官方给的示例，使用的是root用户启动的容器。在我后面的测试中发现，我在使用非root用户启动容器的时候，发现使用静态供给是有权限并且没有报错的。但是在使用静载供给的时候出现了 Operation not permitted 的报错。

问题描述

我根据efs dynamic_provisioning 创建了 dynamic provisioning
root用户的容器运行没有问题，但是非root用户容器运行时提示 “Operation not permitted”

pod配置清单：

apiVersion: v1
kind: Service
metadata:
  name: wordpress-mysql
  labels:
    app: wordpress
spec:
  ports:
    - port: 3306
  selector:
    app: wordpress
    tier: mysql
  clusterIP: None
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pv-claim
  labels:
    app: wordpress
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
---
apiVersion: apps/v1 # for versions before 1.9.0 use apps/v1beta2
kind: Deployment
metadata:
  name: wordpress-mysql
  labels:
    app: wordpress
spec:
  selector:
    matchLabels:
      app: wordpress
      tier: mysql
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: wordpress
        tier: mysql
    spec:
      containers:
      - image: mysql:5.6
        name: mysql
        env:
        - name: MYSQL_ROOT_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-pass
              key: password
        ports:
        - containerPort: 3306
          name: mysql
        volumeMounts:
        - name: mysql-persistent-storage
          mountPath: /var/lib/mysql
      volumes:
      - name: mysql-persistent-storage
        persistentVolumeClaim:
          claimName: mysql-pv-claim

StorageClass配置清单：

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: efs-sc
provisioner: efs.csi.aws.com
parameters:
  provisioningMode: efs-ap
  fileSystemId: fs-xxxxx
  directoryPerms: "700"
  gidRangeStart: "1000" # optional
  gidRangeEnd: "2000" # optional
  basePath: "/dynamic_provisioning" # optional

分析和检查

该报错是由于采用了dynamic provisioning PV部署方式，这种模式的实现需要利用 efs-ap：access point访问点 模式做 EFS 挂载。从 EFS 的角度来讲，EFS 的 access point 模式挂载的 EFS 卷，客户端不可修改 uid/gid ，只拥有使用权（读写）详情点击查看。从自己的pod环境也可以看到，客户端挂载目录/dynamic_provisioning 的uid跟gid都是一个随机数字。 ls -l /dynamic_provisioning可以看到是 `1018 （不同环境uid会不同）。

EFS-AP模式指的是access point访问点模式。关于访问点的介绍：
EFS Access Points：
An access point applies an operating system user, group, and file system path to any file system request made using the access point. The access point’s operating system user and group override any identity information provided by the NFS client.
简单来讲，EFS-AP也就是access point访问点挂载模式下，efs客户端的路径user/gid是不可被修改的。的客户端用户只有使用权（读写），但是不可以修改owner。因此遇到的报错是该配置的预期表现。

EFS-AP模式的配置是在storageclass中定义的：provisioningMode: efs-ap，比如：

kind: StorageClass
apiVersion: storage.k8s.io/v1 
metadata:
  name: efs-sc-dynamic
provisioner: efs.csi.aws.com 
parameters:
  provisioningMode: efs-ap    <<<<<<<<<<<<<<------------------------------EFS访问点挂载模式
  fileSystemId: fs-xxxxxx
  directoryPerms: "700"
  gidRangeStart: "1000" # optional
  gidRangeEnd: "2000" # optional
  basePath: "/dynamic_provisioning" # optional

目前AWS EFS的 dynamic provisioning 模式的实现就是使用 storageclass 的 efs-sc-dynamic 模式。
这种模式的弊端已经在 github 中有issue在跟踪,详情点击查看，但是由于该模式也有一定的设计意义详情点击查看，所以目前还没有明确的结论。

临时解决方法

使用静态模式创建

可以创建EKS pv/pvc时使用static模式部署PV，不会使用access point模式挂载EFS卷，那么可以顺利修改uid/gid。
详情参考Amazon EKS 中 EFS 持久性存储

在pod中指定 uid 和 gid

在创建pod之前，先创建 pvc在创建完pvc后查看uid 和gid

[root@ip-10-0-100-206 ~]# ls -l /efs/dynamic_provisioning/
total 12
drwxr-xr-x 5 1015 1015 6144 Jan 20 02:44 pvc-40b922c7-8d4d-47d9-8783-60d25abe123
drwxr-xr-x 5 1017 1017 6144 Jan 20 04:22 pvc-4ee000a8-7ab2-4ffc-8fd3-72ef31b7123
drwx------ 5 1014 1014 6144 Jan 20 01:08 pvc-f6622cb3-7c24-4172-a427-d4b9a996122

将输出内容的pvc的uid gid 记下并在pod的yaml清单中指定uid已经gid让pod拥有该目录的权限。
pod配置清单：

apiVersion: v1
kind: Service
metadata:
  name: wordpress-mysql
  labels:
    app: wordpress
spec:
  ports:
    - port: 3306
  selector:
    app: wordpress
    tier: mysql
  clusterIP: None
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pv-claim
  labels:
    app: wordpress
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 5Gi
---
apiVersion: apps/v1 # for versions before 1.9.0 use apps/v1beta2
kind: Deployment
metadata:
  name: wordpress-mysql
  labels:
    app: wordpress
spec:
  selector:
    matchLabels:
      app: wordpress
      tier: mysql
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: wordpress
        tier: mysql
    spec:
      securityContext:
        fsGroup: 1014
        runAsUser: 1014
        runAsGroup: 1014
      containers:
      - image: mysql:5.6
        name: mysql
        env:
        - name: MYSQL_ROOT_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-pass
              key: password
        ports:
        - containerPort: 3306
          name: mysql
        volumeMounts:
        - name: mysql-persistent-storage
          mountPath: /var/lib/mysql
      volumes:
      - name: mysql-persistent-storage
        persistentVolumeClaim:
          claimName: mysql-pv-claim

检查

kubectl get pv|grep  mysql 
pvc-f6622cb3-7c24-4172-a427-d4b9a9962cd8   5Gi   RWX   Delete   Bound   default/mysql-pv-claim   efs-sc      5d23h

kubectl get  pvc
NAME             STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS   AGE
mysql-pv-claim   Bound    pvc-f6622cb3-7c24-4172-a427-d4b9a9962cd8   5Gi        RWX            efs-sc         5d23h

kubectl get  pod
NAME                               READY   STATUS    RESTARTS   AGE
wordpress-mysql-6f6455f449-52zrp   1/1     Running   0          5d7h

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/220125450139/
相关话题：https://www.cnsre.cn/tags/eks/

Amazon EKS 中 EFS 持久性存储

Wenlong — Mon, 10 Jan 2022 08:50:57 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/220110850573/
相关话题：https://www.cnsre.cn/tags/eks/

学习目标

在 EKS 中部署 Amazon EFS CSI 驱动程序到
验证 EFS 并验证它是否正常工作
创建基于 EFS 的静态、动态存储

前提条件

EKS 集群
AWS CLI 如果你没有安装请查看安装、更新和卸载 AWS CLI。在安装 AWS CLI 后，还要对其进行配置。
kubectl 如果没有安装请查看安装 kubectl。

创建 IAM 策略

创建 IAM 策略并将其分配给 IAM 角色。该策略将允许 Amazon EFS 驱动程序与文件系统交互。

1.从查看下方 IAM 策略文档或者查看策略文档。

推荐使用查看策略文档。获取策略文档。

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "elasticfilesystem:DescribeAccessPoints",
        "elasticfilesystem:DescribeFileSystems"
      ],
      "Resource": "*"
    },
    {
      "Effect": "Allow",
      "Action": [
        "elasticfilesystem:CreateAccessPoint"
      ],
      "Resource": "*",
      "Condition": {
        "StringLike": {
          "aws:RequestTag/efs.csi.aws.com/cluster": "true"
        }
      }
    },
    {
      "Effect": "Allow",
      "Action": "elasticfilesystem:DeleteAccessPoint",
      "Resource": "*",
      "Condition": {
        "StringEquals": {
          "aws:ResourceTag/efs.csi.aws.com/cluster": "true"
        }
      }
    }
  ]
}

2.在IAM-策略中创建策略

在Identity and Access Management (IAM)中点击 策略 然后在下一步中点击 创建策略

点击 json 然后将 IAM 策略 填入，然后点击 下一步:标签

在下一步的标签中，可以根据自己的情况自行填写,然后点击 下一步:审核

名称中填写 AmazonEKS_EFS_CSI_Driver_Policy

你可以将 AmazonEKS_EFS_CSI_Driver_Policy 更改为其他名称，但如果更改，请确保在后续步骤中也做出相应更改。

将 efs 策略附件到 eks node 角色中

将我们刚才创建的 efs 策略 AmazonEKS_EFS_CSI_Driver_Policy 附加在 eks_node 的角色中，确保eks node拥有efs的权限。

如果你之前创建了 eks 那么在你的角色中会有一个名为 eksctl-<eks-name>-nodegrou-NodeInstanceRole-xxxxxxxxx 的角色。

在角色中搜索 node 然后点击 eksctl-<eks-name>-nodegrou-NodeInstanceRole-xxxxxxxxx

在角色中点击 附加策略

搜索之前创建的 EFS 策略也就是 AmazonEKS_EFS_CSI_Driver_Policy 然后选中，点击最下方的附加策略。

安装 Amazon EFS 驱动程序

使用 Helm 或 yaml 清单安装 Amazon EFS CSI 驱动程序。
这边不详细说 helm 部署方式主要介绍 yaml 清单部署

一定要修改镜像地址为你所在的地区 Amazon EKS 附加组件容器镜像地址

yaml 清单部署

因为github网络的问题。如果再执行的时候部署没有反应，请终止运行，多运行几次尝试部署

`1`	`kubectl apply -k "github.com/kubernetes-sigs/aws-efs-csi-driver/deploy/kubernetes/overlays/stable/?ref=release-1.3"`

输出如下：

serviceaccount/efs-csi-controller-sa created
serviceaccount/efs-csi-node-sa created
clusterrole.rbac.authorization.k8s.io/efs-csi-external-provisioner-role created
clusterrolebinding.rbac.authorization.k8s.io/efs-csi-provisioner-binding created
deployment.apps/efs-csi-controller created
daemonset.apps/efs-csi-node created
csidriver.storage.k8s.io/efs.csi.aws.com created

检查驱动运行是否正常

kubectl  get  pods -A|grep  efs
kube-system                    efs-csi-controller-56f6dc4c76-2lvqf               3/3     Running     0          3m32s
kube-system                    efs-csi-controller-56f6dc4c76-dxkwl               3/3     Running     0          3m32s
kube-system                    efs-csi-node-9ttxp                                3/3     Running     0          3m32s
kube-system                    efs-csi-node-hsn94                                3/3     Running     0          3m32s

虽然这边显示运行正常，但是还是要修改镜像地址。不然在创建pv，pvc以后在pod中挂载会出现错误。（后面会单独记录这个错误）

修改 efs-csi-node 驱动

`1`	`kubectl edit daemonsets.apps -n kube-system efs-csi-node`

找到 aws-efs-csi-driver 驱动所在的位置

然后将镜像修改为 918309763551.dkr.ecr.cn-north-1.amazonaws.com.cn/eks/aws-efs-csi-driver:v1.3.3

具体如下

创建 Amazon EFS 文件系统

为 Amazon EKS 集群创建 Amazon EFS 文件系统

在控制台中搜索 efs 点击确认然后进入 EFS 控制台

在控制台中点击 创建文件系统

名称：根据自己的情况填写
vpc：一定要创建在跟 eks 同一 VPC 下
可用性和持久性: 根据提示说明创建自己所需要的
如果有更多需求可以点击 自定义来设置更多 如：吞吐量、加密、备份等策略
最后点击 创建

创建入站规则

允许来自 EKS 集群 VPC 的 CIDR 的入站 NFS 流量
在刚刚创建的 EFS 中选择 网络 –> 安全组 然后复制安全组的ID sg-152XXX

在 EC2 中找到 网络与安全 选择 安全组 然后在搜索框中搜索 sg-152XXX 选中安全组。并选择 入站规则

在入站规则中允许来 EKS 集群来访问 NFS(2049)端口流量。

部署示例应用程序

部署静态供给

部署使用你创建的持久性卷的示例应用程序

此过程利用来自 Amazon EFS Container Storage Interface (CSI) 驱动程序 GitHub 存储库的多个 Pod 读写许多示例来使用静态预置的 Amazon EFS 持久性卷，并使用 ReadWriteMany 访问模式从多个 Pod 访问它。

将 Amazon EFS Container Storage Interface (CSI) 驱动程序 GitHub 存储库克隆到你的本地系统。
```
git clone https://github.com/kubernetes-sigs/aws-efs-csi-driver.git
```

导航到 multiple_pods 示例目录。

cd aws-efs-csi-driver/examples/kubernetes/multiple_pods/

检索你的 Amazon EFS 文件系统 ID。你可以在 Amazon EFS 控制台中查找此信息，或者使用以下 AWS CLI 命令。
```
aws efs describe-file-systems --query "FileSystems[*].FileSystemId" --output text
```
输出：
```
fs-<582a03f3>
```
编辑 specs/pv.yaml 文件并将 volumeHandle 值替换为你的 Amazon EFS 文件系统 ID。
```
apiVersion: v1
kind: PersistentVolume
metadata:
  name: efs-pv
spec:
  capacity:
    storage: 5Gi
  volumeMode: Filesystem
  accessModes:
    - ReadWriteMany
  persistentVolumeReclaimPolicy: Retain
  storageClassName: efs-sc
  csi:
    driver: efs.csi.aws.com
    volumeHandle: fs-<582a03f3>
```
注意

由于 Amazon EFS 是弹性文件系统，因此它不会强制实施任何文件系统容量限制。在创建系统时，不使用持久性卷和持久性卷声明中的实际存储容量值。但是，由于存储容量是 Kubernetes 中的必需字段，你必须指定有效值，例如，在此示例中为 5Gi。此值不会限制 Amazon EFS 文件系统的大小。

从 specs 目录部署 efs-sc 存储类、efs-claim 持久性卷声明以及 efs-pv 持久性卷。

kubectl apply -f specs/pv.yaml
kubectl apply -f specs/claim.yaml
kubectl apply -f specs/storageclass.yaml

列出默认命名空间中的持久性卷。查找具有 default/efs-claim 声明的持久性卷。

kubectl get pv -w

输出：

NAME     CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM               STORAGECLASS   REASON   AGE
efs-pv   5Gi        RWX            Retain           Bound    default/efs-claim   efs-sc                  2m50s

在 STATUS 变为 Bound 之前，请勿继续执行下一步。

从 specs 目录部署 app1 和 app2 示例应用程序。

kubectl apply -f specs/pod1.yaml
kubectl apply -f specs/pod2.yaml

查看默认命名空间中的 Pod 并等待 app1 和 app2 Pod 的 STATUS 变为 Running 状态。
```
kubectl get pods --watch
```
注意

可能需要几分钟 Pod 才能达到 Running 状态。

描述持久性卷。

kubectl describe pv efs-pv

输出：

Name:            efs-pv
Labels:          none
Annotations:     kubectl.kubernetes.io/last-applied-configuration:
                   {"apiVersion":"v1","kind":"PersistentVolume","metadata":{"annotations":{},"name":"efs-pv"},"spec":{"accessModes":["ReadWriteMany"],"capaci...
                 pv.kubernetes.io/bound-by-controller: yes
Finalizers:      [kubernetes.io/pv-protection]
StorageClass:    efs-sc
Status:          Bound
Claim:           default/efs-claim
Reclaim Policy:  Retain
Access Modes:    RWX
VolumeMode:      Filesystem
Capacity:        5Gi
Node Affinity:   none
Message:
Source:
    Type:              CSI (a Container Storage Interface (CSI) volume source)
    Driver:            efs.csi.aws.com
    VolumeHandle:      fs-582a03f3
    ReadOnly:          false
    VolumeAttributes:  none
Events:                none

Amazon EFS 文件系统 ID 将作为 VolumeHandle 列出。

验证 app1 Pod 是否成功将数据写入卷。

kubectl exec -ti app1 -- tail /data/out1.txt

输出：

...
Mon Mar 22 18:18:22 UTC 2021
Mon Mar 22 18:18:27 UTC 2021
Mon Mar 22 18:18:32 UTC 2021
Mon Mar 22 18:18:37 UTC 2021
...

验证 app2 Pod 在卷中显示的数据与 app1 写入卷的数据相同。

kubectl exec -ti app2 -- tail /data/out1.txt

输出：

...
Mon Mar 22 18:18:22 UTC 2021
Mon Mar 22 18:18:27 UTC 2021
Mon Mar 22 18:18:32 UTC 2021
Mon Mar 22 18:18:37 UTC 2021
...

完成试验时，请删除此示例应用程序的资源以进行清理。
```
kubectl delete -f specs/
```
你还可以手动删除你创建的文件系统和安全组。

部署动态供给

Prerequisite

您必须使用 1.2x 版或更高版本的 Amazon EFS CSI 驱动程序，该驱动程序需要 1.17 或更高版本的集群。要更新集群，请参阅更新集群。

部署使用控制器所创建的持久性卷的示例应用程序

此过程利用来自 Amazon EFS Container Storage Interface (CSI) 驱动程序 GitHub 存储库的动态预置示例。它通过 Amazon EFS 接入点和 Pod 使用的持久性卷申领 (PVC) 动态创建一个持久性卷。

为 EFS 创建存储类。有关所有参数和配置选项，请参阅 GitHub 上的 Amazon EFS CSI 驱动程序。
1. 下载 Amazon EFS 的 StorageClass 清单。
```
curl -o storageclass.yaml https://raw.githubusercontent.com/kubernetes-sigs/aws-efs-csi-driver/master/examples/kubernetes/dynamic_provisioning/specs/storageclass.yaml
```
2. 编辑相应文件，将 fileSystemId 的值替换为您的文件系统 ID。
3. 部署存储类。
```
kubectl apply -f storageclass.yaml
```
通过部署利用 PersistentVolumeClaim 的 Pod 来测试自动预置：
1. 下载一个清单，该清单将部署一个 Pod 和一个 PersistentVolumeClaim。
```
curl -o pod.yaml https://raw.githubusercontent.com/kubernetes-sigs/aws-efs-csi-driver/master/examples/kubernetes/dynamic_provisioning/specs/pod.yaml
```
2. 使用示例应用程序和 Pod 使用的 PersistentVolumeClaim 来部署 Pod。
```
kubectl apply -f pod.yaml
```

确定运行控制器的 Pod 的名称。

kubectl get pods -n kube-system | grep efs-csi-controller

输出

efs-csi-controller-74ccf9f566-q5989   3/3     Running   0          40m
efs-csi-controller-74ccf9f566-wswg9   3/3     Running   0          40m

几秒钟后，您可以观察到控制器开始接受更改（已编辑，旨在提高可读性）。将 74ccf9f566-q5989 替换成来自上一个命令输出中的一个 Pod 的值。
```
kubectl logs efs-csi-controller-74ccf9f566-q5989 \
    -n kube-system \
    -c csi-provisioner \
    --tail 10
```
输出
```
...
1 controller.go:737] successfully created PV pvc-5983ffec-96cf-40c1-9cd6-e5686ca84eca for PVC efs-claim and csi volume name fs-95bcec92::fsap-02a88145b865d3a87
```
如果未看到上一个输出，请使用其他控制器 Pod 之一运行上一个命令。

确认已创建状态为 Bound 至 PersistentVolumeClaim 的持久性卷：

kubectl get pv

输出

NAME                                       CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM               STORAGECLASS   REASON   AGE
pvc-5983ffec-96cf-40c1-9cd6-e5686ca84eca   20Gi       RWX            Delete           Bound    default/efs-claim   efs-sc                  7m57s

查看有关所创建的 PersistentVolumeClaim 的详细信息。

kubectl get pvc

输出

NAME        STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS   AGE
efs-claim   Bound    pvc-5983ffec-96cf-40c1-9cd6-e5686ca84eca   20Gi       RWX            efs-sc         9m7s

查看示例应用程序 Pod 的状态。

kubectl get pods -o wide

输出

NAME          READY   STATUS    RESTARTS   AGE   IP               NODE                                           NOMINATED NODE   READINESS GATES
efs-example   1/1     Running   0          10m   192.168.78.156   ip-192-168-73-191.us-west-2.compute.internal   <none>           <none>

确认数据已写入到卷。

kubectl exec efs-app -- bash -c "cat data/out"

输出

...
Tue Mar 23 14:29:16 UTC 2021
Tue Mar 23 14:29:21 UTC 2021
Tue Mar 23 14:29:26 UTC 2021
Tue Mar 23 14:29:31 UTC 2021
...

（可选）终止运行 Pod 的 Amazon EKS 节点并等待重新安排运行 Pod。或者，您也可以删除 Pod 并重新部署它。再次完成步骤 7，确认输出包含先前的输出。

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/220110850573/
相关话题：https://www.cnsre.cn/tags/eks/

如何彻底删除EKS中一直卡在Terminating的Namespace

Wenlong — Fri, 07 Jan 2022 09:06:44 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/220107906441/
相关话题：https://www.cnsre.cn/tags/eks/

介绍

最近一直在玩EKS（Elastic Kubernetes Service – Amazon EKS）和 kubesphere。因为之前没有使用过EKS 和 kubesphere 所以这个过程也是一个试错的过程，在我使用 kubesphere 的时候发现有一个日志服务，在好奇心的驱使下，我创建了它。

在我创建了日志服务（KubeSphere Logging System）以后，我发现我并不想使用它。（可能我只是想看看它到底是什么吧。）强迫症我的，就想把它给删除掉。于是我在我的 EKS 中对他进行了强制删除 kubectl delete ns kubesphere-logging-system --force --grace-period=0

让人尴尬的是，这个 Namespace 并没有立马删除，我自我安慰到，可能 Namespace 下边有其他没有删除的资源在等待删除，我在等等。。。

过了半个小时，我去查看的时候

[root@ip-10-0-100-206 ~]# kubectl get  ns  kubesphere-logging-system
NAME                              STATUS        AGE
kubesphere-logging-system         Terminating   6d19h

它好像这地卡在了 Terminating 的状态。
我试着寻找解决方法，http://github.com/kubernetes/kubernetes/issues/60807 但是这中方法要通过 API 才可以实现。EKS 是托管在 AWS 中的，我根本没有办法去操作eks的后台。

我开始后悔我为什么要去安装它，我本可以不折腾的。但是回想如果我不去安装它的话，我肯定会像想在这样难过，因为我无法了解它（KubeSphere Logging System）到底是什么样的。

终于我找到了 commented https://github.com/kubernetes/kubernetes/issues/60807#issuecomment-663853215

如何彻底删除 namespace

获取namespace的详情信息并转为json

`1`	`kubectl get namespace kubesphere-logging-system -o json > kubesphere-logging-system.json`

打开 json 文件编辑

{
    "apiVersion": "v1",
    "kind": "Namespace",
    "metadata": {
        "creationTimestamp": "2021-12-31T05:03:58Z",
        "deletionTimestamp": "2022-01-05T08:05:40Z",
        "labels": {
            "kubesphere.io/namespace": "kubesphere-logging-system",
            "kubesphere.io/workspace": "system-workspace"
        },
        "managedFields": [
            {
                "apiVersion": "v1",
                "fieldsType": "FieldsV1",
                "fieldsV1": {
                    "f:metadata": {
                        "f:labels": {
                            ".": {},
                            "f:kubesphere.io/namespace": {}
                        },
                        "f:ownerReferences": {
                            ".": {},
                            "k:{\"uid\":\"6d535470-2592-4f3c-a155-eabc362c339d\"}": {
                                ".": {},
                                "f:apiVersion": {},
                                "f:blockOwnerDeletion": {},
                                "f:controller": {},
                                "f:kind": {},
                                "f:name": {},
                                "f:uid": {}
                            }
                        }
                    }
                },
                "manager": "controller-manager",
                "operation": "Update",
                "time": "2021-12-31T05:04:01Z"
            },
            {
                "apiVersion": "v1",
                "fieldsType": "FieldsV1",
                "fieldsV1": {
                    "f:metadata": {
                        "f:labels": {
                            "f:kubesphere.io/workspace": {}
                        }
                    },
                    "f:status": {
                        "f:phase": {}
                    }
                },
                "manager": "kubectl",
                "operation": "Update",
                "time": "2021-12-31T05:04:01Z"
            },
            {
                "apiVersion": "v1",
                "fieldsType": "FieldsV1",
                "fieldsV1": {
                    "f:status": {
                        "f:conditions": {
                            ".": {},
                            "k:{\"type\":\"NamespaceContentRemaining\"}": {
                                ".": {},
                                "f:lastTransitionTime": {},
                                "f:message": {},
                                "f:reason": {},
                                "f:status": {},
                                "f:type": {}
                            },
                            "k:{\"type\":\"NamespaceDeletionContentFailure\"}": {
                                ".": {},
                                "f:lastTransitionTime": {},
                                "f:message": {},
                                "f:reason": {},
                                "f:status": {},
                                "f:type": {}
                            },
                            "k:{\"type\":\"NamespaceDeletionDiscoveryFailure\"}": {
                                ".": {},
                                "f:lastTransitionTime": {},
                                "f:message": {},
                                "f:reason": {},
                                "f:status": {},
                                "f:type": {}
                            },
                            "k:{\"type\":\"NamespaceDeletionGroupVersionParsingFailure\"}": {
                                ".": {},
                                "f:lastTransitionTime": {},
                                "f:message": {},
                                "f:reason": {},
                                "f:status": {},
                                "f:type": {}
                            },
                            "k:{\"type\":\"NamespaceFinalizersRemaining\"}": {
                                ".": {},
                                "f:lastTransitionTime": {},
                                "f:message": {},
                                "f:reason": {},
                                "f:status": {},
                                "f:type": {}
                            }
                        }
                    }
                },
                "manager": "kube-controller-manager",
                "operation": "Update",
                "time": "2022-01-05T08:05:47Z"
            }
        ],
        "name": "kubesphere-logging-system",
        "ownerReferences": [
            {
                "apiVersion": "tenant.kubesphere.io/v1alpha1",
                "blockOwnerDeletion": true,
                "controller": true,
                "kind": "Workspace",
                "name": "system-workspace",
                "uid": "6d535470-2592-4f3c-a155-eabc362c339d"
            }
        ],
        "resourceVersion": "7376520",
        "uid": "2b76e9b1-75f2-4a2e-a819-73b36aea188e"
    },
    "spec": {
        "finalizers": [
            "kubernetes" # 将此行删除
        ]
    },
    "status": {
        "conditions": [
            {
                "lastTransitionTime": "2022-01-05T08:05:47Z",
                "message": "All resources successfully discovered",
                "reason": "ResourcesDiscovered",
                "status": "False",
                "type": "NamespaceDeletionDiscoveryFailure"
            },
            {
                "lastTransitionTime": "2022-01-05T08:05:47Z",
                "message": "All legacy kube types successfully parsed",
                "reason": "ParsedGroupVersions",
                "status": "False",
                "type": "NamespaceDeletionGroupVersionParsingFailure"
            },
            {
                "lastTransitionTime": "2022-01-05T08:05:47Z",
                "message": "All content successfully deleted, may be waiting on finalization",
                "reason": "ContentDeleted",
                "status": "False",
                "type": "NamespaceDeletionContentFailure"
            },
            {
                "lastTransitionTime": "2022-01-05T08:05:47Z",
                "message": "Some resources are remaining: fluentbits.logging.kubesphere.io has 1 resource instances",
                "reason": "SomeResourcesRemain",
                "status": "True",
                "type": "NamespaceContentRemaining"
            },
            {
                "lastTransitionTime": "2022-01-05T08:05:47Z",
                "message": "Some content in the namespace has finalizers remaining: fluentbit.logging.kubesphere.io in 1 resource instances",
                "reason": "SomeFinalizersRemain",
                "status": "True",
                "type": "NamespaceFinalizersRemaining"
            }
        ],
        "phase": "Terminating"
    }
}

找到 spec 将 finalizers 下的 kubernetes 删除
具体如下

{
    "apiVersion": "v1",
    "kind": "Namespace",
    "metadata": {
        "creationTimestamp": "2021-12-31T05:03:58Z",
        "deletionTimestamp": "2022-01-05T08:05:40Z",
        "labels": {
            "kubesphere.io/namespace": "kubesphere-logging-system",
            "kubesphere.io/workspace": "system-workspace"
        },
        "managedFields": [
            {
                "apiVersion": "v1",
                "fieldsType": "FieldsV1",
                "fieldsV1": {
                    "f:metadata": {
                        "f:labels": {
                            ".": {},
                            "f:kubesphere.io/namespace": {}
                        },
                        "f:ownerReferences": {
                            ".": {},
                            "k:{\"uid\":\"6d535470-2592-4f3c-a155-eabc362c339d\"}": {
                                ".": {},
                                "f:apiVersion": {},
                                "f:blockOwnerDeletion": {},
                                "f:controller": {},
                                "f:kind": {},
                                "f:name": {},
                                "f:uid": {}
                            }
                        }
                    }
                },
                "manager": "controller-manager",
                "operation": "Update",
                "time": "2021-12-31T05:04:01Z"
            },
            {
                "apiVersion": "v1",
                "fieldsType": "FieldsV1",
                "fieldsV1": {
                    "f:metadata": {
                        "f:labels": {
                            "f:kubesphere.io/workspace": {}
                        }
                    },
                    "f:status": {
                        "f:phase": {}
                    }
                },
                "manager": "kubectl",
                "operation": "Update",
                "time": "2021-12-31T05:04:01Z"
            },
            {
                "apiVersion": "v1",
                "fieldsType": "FieldsV1",
                "fieldsV1": {
                    "f:status": {
                        "f:conditions": {
                            ".": {},
                            "k:{\"type\":\"NamespaceContentRemaining\"}": {
                                ".": {},
                                "f:lastTransitionTime": {},
                                "f:message": {},
                                "f:reason": {},
                                "f:status": {},
                                "f:type": {}
                            },
                            "k:{\"type\":\"NamespaceDeletionContentFailure\"}": {
                                ".": {},
                                "f:lastTransitionTime": {},
                                "f:message": {},
                                "f:reason": {},
                                "f:status": {},
                                "f:type": {}
                            },
                            "k:{\"type\":\"NamespaceDeletionDiscoveryFailure\"}": {
                                ".": {},
                                "f:lastTransitionTime": {},
                                "f:message": {},
                                "f:reason": {},
                                "f:status": {},
                                "f:type": {}
                            },
                            "k:{\"type\":\"NamespaceDeletionGroupVersionParsingFailure\"}": {
                                ".": {},
                                "f:lastTransitionTime": {},
                                "f:message": {},
                                "f:reason": {},
                                "f:status": {},
                                "f:type": {}
                            },
                            "k:{\"type\":\"NamespaceFinalizersRemaining\"}": {
                                ".": {},
                                "f:lastTransitionTime": {},
                                "f:message": {},
                                "f:reason": {},
                                "f:status": {},
                                "f:type": {}
                            }
                        }
                    }
                },
                "manager": "kube-controller-manager",
                "operation": "Update",
                "time": "2022-01-05T08:05:47Z"
            }
        ],
        "name": "kubesphere-logging-system",
        "ownerReferences": [
            {
                "apiVersion": "tenant.kubesphere.io/v1alpha1",
                "blockOwnerDeletion": true,
                "controller": true,
                "kind": "Workspace",
                "name": "system-workspace",
                "uid": "6d535470-2592-4f3c-a155-eabc362c339d"
            }
        ],
        "resourceVersion": "7376520",
        "uid": "2b76e9b1-75f2-4a2e-a819-73b36aea188e"
    },
    "spec": {
        "finalizers": [
        ]
    },
    "status": {
        "conditions": [
            {
                "lastTransitionTime": "2022-01-05T08:05:47Z",
                "message": "All resources successfully discovered",
                "reason": "ResourcesDiscovered",
                "status": "False",
                "type": "NamespaceDeletionDiscoveryFailure"
            },
            {
                "lastTransitionTime": "2022-01-05T08:05:47Z",
                "message": "All legacy kube types successfully parsed",
                "reason": "ParsedGroupVersions",
                "status": "False",
                "type": "NamespaceDeletionGroupVersionParsingFailure"
            },
            {
                "lastTransitionTime": "2022-01-05T08:05:47Z",
                "message": "All content successfully deleted, may be waiting on finalization",
                "reason": "ContentDeleted",
                "status": "False",
                "type": "NamespaceDeletionContentFailure"
            },
            {
                "lastTransitionTime": "2022-01-05T08:05:47Z",
                "message": "Some resources are remaining: fluentbits.logging.kubesphere.io has 1 resource instances",
                "reason": "SomeResourcesRemain",
                "status": "True",
                "type": "NamespaceContentRemaining"
            },
            {
                "lastTransitionTime": "2022-01-05T08:05:47Z",
                "message": "Some content in the namespace has finalizers remaining: fluentbit.logging.kubesphere.io in 1 resource instances",
                "reason": "SomeFinalizersRemain",
                "status": "True",
                "type": "NamespaceFinalizersRemaining"
            }
        ],
        "phase": "Terminating"
    }
}

执行清理命令

现在我们只需要一条命令就可以彻底删除这个 Namespace

`1`	`kubectl replace --raw "/api/v1/namespaces/kubesphere-logging-system/finalize" -f ./kubesphere-logging-system.json`

执行完以后，你需要等待一会
再次执行命令检查 namespaces

`1`	`kubectl replace --raw "/api/v1/namespaces/kubesphere-logging-system/finalize" -f ./kubesphere-logging-system.json`

最后的检查

kubectl get  ns  kubesphere-logging-system
Error from server (NotFound): namespaces "kubesphere-logging-system" not found

[root@ip-10-0-100-206 ~]# kubectl get  ns 
NAME                              STATUS   AGE
default                           Active   23d
kubesphere-controls-system        Active   9d
kubesphere-devops-system          Active   9d
kubesphere-devops-worker          Active   16h
kubesphere-monitoring-federated   Active   9d
kubesphere-monitoring-system      Active   9d
kubesphere-sample-dev             Active   8d
kubesphere-system                 Active   9d

在此查看的时候，它已经不存在了。

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/220107906441/
相关话题：https://www.cnsre.cn/tags/eks/

AWS eks绑定alb 使用aws-load-balancer-controller(Ingress Controller)提供服务

Wenlong — Fri, 17 Dec 2021 14:31:13 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211217431135/
相关话题：https://www.cnsre.cn/tags/aws/

最近在AWS 平台创建了EKS 用于测试环境项目，EKS 创建完以后我打算使用 Ingress 控制器来暴露服务，ingress 前在添加一个ALB 负载均衡器，这样就可以实现完全的高可用了。但是在创建好 ingress 却发现无法调通服务，查看 aws 官方文档 Amazon EKS 上的应用程序负载均衡发现需要使用 aws-load-balancer-controller.

本文档的目标：

创建 EKS ALB 所需要的角色。
创建 EKS aws-load-balancer-controller
创建 EKS pod 服务
使用 ALB 将 pod 服务暴露出去

AWS Load Balancer Controller 介绍

AWS Load Balancer Controller 的工作原理

AWS Load Balancer Controller 是帮助管理 Kubernetes 集群的弹性负载均衡器的控制器。

它通过供应应用程序负载均衡器来满足 Kubernetes Ingress 资源。
它通过提供网络负载均衡器来满足 Kubernetes Service 资源。

下图详细说明了此控制器创建的 AWS 组件。它还演示了从 ALB 到 Kubernetes 集群的路由入口流量。

[1]：控制器监视来自 API 服务器的入口事件。当它找到满足其要求的入口资源时，它开始创建 AWS 资源。

[2]：在 AWS 中为新的入口资源创建了一个 ALB (ELBv2)。此 ALB 可以面向 Internet 或内部。您还可以使用注释指定它在其中创建的子网。

[3]：在 AWS 中为入口资源中描述的每个独特的 Kubernetes 服务创建目标组。

[4]：为入口资源注释中详述的每个端口创建侦听器。如果未指定端口，则使用合理的默认值 (80或443)。证书也可以通过注释附加。

[5]：为入口资源中指定的每个路径创建规则。这可确保将特定路径的流量路由到正确的 Kubernetes 服务。

安装前的准备

EKS 已经创建完毕
准备两个 Public 子网
能够创建 IAM 策略的账户

关于子网的说明：

根据EKS 最佳实践。EKS 的 worker node，它们只需要接收来自 alb ingress（通过内网转发）的流量，安全起见就需要把他们放在私有子网。但是它们又需要去公网上拉一些镜像，所以它们本身也需要放问公网的能力，这个时候它们的子网里配置个 nat，访问外网的时候由 NAT 做一个出向的转发，就可以实现了，但是因为 nat 是单向的，外界是无法通过NAT访问到eks的节点的，所以我就需要将ALB 放在 public 子网里。最后就是 ALB 放在 public 来接受流量，worker node 在私有子网处理业务。

创建AWS Load Balancer Controller 的 IAM 策略

打开策略点击 创建策略 打开 IAM_Policy.json 复制内容粘贴到 json

点击下一步:标签

然后一直下一步在下图中名称填写 AWSLoadBalancerControllerIAMPolicy 你也可以自定义名称。然后创建策略。

如果以官方提供的 IAM_Policy.json 保存有错的话你可以使用一下策略（权限会大一些）

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "iam:CreateServiceLinkedRole",
                "ec2:DescribeAccountAttributes",
                "ec2:DescribeAddresses",
                "ec2:DescribeAvailabilityZones",
                "ec2:DescribeInternetGateways",
                "ec2:DescribeVpcs",
                "ec2:DescribeSubnets",
                "ec2:DescribeSecurityGroups",
                "ec2:DescribeInstances",
                "ec2:DescribeNetworkInterfaces",
                "ec2:DescribeTags",
                "ec2:GetCoipPoolUsage",
                "ec2:DescribeCoipPools",
                "elasticloadbalancing:DescribeLoadBalancers",
                "elasticloadbalancing:DescribeLoadBalancerAttributes",
                "elasticloadbalancing:DescribeListeners",
                "elasticloadbalancing:DescribeListenerCertificates",
                "elasticloadbalancing:DescribeSSLPolicies",
                "elasticloadbalancing:DescribeRules",
                "elasticloadbalancing:DescribeTargetGroups",
                "elasticloadbalancing:DescribeTargetGroupAttributes",
                "elasticloadbalancing:DescribeTargetHealth",
                "elasticloadbalancing:DescribeTags"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "cognito-idp:DescribeUserPoolClient",
                "acm:ListCertificates",
                "acm:DescribeCertificate",
                "iam:ListServerCertificates",
                "iam:GetServerCertificate",
                "waf-regional:GetWebACL",
                "waf-regional:GetWebACLForResource",
                "waf-regional:AssociateWebACL",
                "waf-regional:DisassociateWebACL",
                "wafv2:GetWebACL",
                "wafv2:GetWebACLForResource",
                "wafv2:AssociateWebACL",
                "wafv2:DisassociateWebACL",
                "shield:GetSubscriptionState",
                "shield:DescribeProtection",
                "shield:CreateProtection",
                "shield:DeleteProtection"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "ec2:AuthorizeSecurityGroupIngress",
                "ec2:RevokeSecurityGroupIngress"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "ec2:CreateSecurityGroup"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "ec2:CreateTags"
            ],
            "Resource": "arn:aws-cn:ec2:*:*:security-group/*",
            "Condition": {
                "StringEquals": {
                    "ec2:CreateAction": "CreateSecurityGroup"
                },
                "Null": {
                    "aws:RequestTag/elbv2.k8s.aws/cluster": "false"
                }
            }
        },
        {
            "Effect": "Allow",
            "Action": [
                "ec2:CreateTags",
                "ec2:DeleteTags"
            ],
            "Resource": "arn:aws-cn:ec2:*:*:security-group/*",
            "Condition": {
                "Null": {
                    "aws:RequestTag/elbv2.k8s.aws/cluster": "true",
                    "aws:ResourceTag/elbv2.k8s.aws/cluster": "false"
                }
            }
        },
        {
            "Effect": "Allow",
            "Action": [
                "ec2:AuthorizeSecurityGroupIngress",
                "ec2:RevokeSecurityGroupIngress",
                "ec2:DeleteSecurityGroup"
            ],
            "Resource": "*",
            "Condition": {
                "Null": {
                    "aws:ResourceTag/elbv2.k8s.aws/cluster": "false"
                }
            }
        },
        {
            "Effect": "Allow",
            "Action": [
                "elasticloadbalancing:CreateLoadBalancer",
                "elasticloadbalancing:CreateTargetGroup"
            ],
            "Resource": "*",
            "Condition": {
                "Null": {
                    "aws:RequestTag/elbv2.k8s.aws/cluster": "false"
                }
            }
        },
        {
            "Effect": "Allow",
            "Action": [
                "elasticloadbalancing:CreateListener",
                "elasticloadbalancing:DeleteListener",
                "elasticloadbalancing:CreateRule",
                "elasticloadbalancing:DeleteRule"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "elasticloadbalancing:AddTags",
                "elasticloadbalancing:RemoveTags"
            ],
            "Resource": [
                "arn:aws-cn:elasticloadbalancing:*:*:targetgroup/*/*",
                "arn:aws-cn:elasticloadbalancing:*:*:loadbalancer/net/*/*",
                "arn:aws-cn:elasticloadbalancing:*:*:loadbalancer/app/*/*"
            ],
            "Condition": {
                "Null": {
                    "aws:RequestTag/elbv2.k8s.aws/cluster": "true",
                    "aws:ResourceTag/elbv2.k8s.aws/cluster": "false"
                }
            }
        },
        {
            "Effect": "Allow",
            "Action": [
                "elasticloadbalancing:AddTags",
                "elasticloadbalancing:RemoveTags"
            ],
            "Resource": [
                "arn:aws-cn:elasticloadbalancing:*:*:listener/net/*/*/*",
                "arn:aws-cn:elasticloadbalancing:*:*:listener/app/*/*/*",
                "arn:aws-cn:elasticloadbalancing:*:*:listener-rule/net/*/*/*",
                "arn:aws-cn:elasticloadbalancing:*:*:listener-rule/app/*/*/*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "elasticloadbalancing:ModifyLoadBalancerAttributes",
                "elasticloadbalancing:SetIpAddressType",
                "elasticloadbalancing:SetSecurityGroups",
                "elasticloadbalancing:SetSubnets",
                "elasticloadbalancing:DeleteLoadBalancer",
                "elasticloadbalancing:ModifyTargetGroup",
                "elasticloadbalancing:ModifyTargetGroupAttributes",
                "elasticloadbalancing:DeleteTargetGroup"
            ],
            "Resource": "*",
            "Condition": {
                "Null": {
                    "aws:ResourceTag/elbv2.k8s.aws/cluster": "false"
                }
            }
        },
        {
            "Effect": "Allow",
            "Action": [
                "elasticloadbalancing:RegisterTargets",
                "elasticloadbalancing:DeregisterTargets"
            ],
            "Resource": "arn:aws-cn:elasticloadbalancing:*:*:targetgroup/*/*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "elasticloadbalancing:SetWebAcl",
                "elasticloadbalancing:ModifyListener",
                "elasticloadbalancing:AddListenerCertificates",
                "elasticloadbalancing:RemoveListenerCertificates",
                "elasticloadbalancing:ModifyRule"
            ],
            "Resource": "*"
        }
    ]
}

赋予 EKS node 权限

在角色中搜索 nodegrou-NodeInstanceRole 找到你对应的 EKS 集群如下图

然后点击该角色– 点击附加策略

在搜索框内输入刚才创建的策略名称然后选中，点击最下边的附加策略。

我的策略名称为：AWSLoadBalancerControllerIAMPolicy

在 EKS 中安装 AWS Load Balancer Controller

安装证书管理器

`1`	`kubectl apply --validate=false -f https://github.com/jetstack/cert-manager/releases/download/v1.5.3/cert-manager.yaml`

部署 YAML

下载负载平衡器控制器的规范。

`1`	`wget https://github.com/kubernetes-sigs/aws-load-balancer-controller/releases/download/v2.3.1/v2_3_1_full.yaml`

编辑保存的 yaml 文件，转到部署规范，并将控制器 –cluster-name arg 值设置为您的 EKS 集群名称

apiVersion: apps/v1
kind: Deployment
. . .
name: aws-load-balancer-controller
namespace: kube-system
spec:
    . . .
    template:
        spec:
            containers:
                - args:
                    - --cluster-name=<INSERT_CLUSTER_NAME>

如果您为服务账户使用 IAM 角色，我们建议您从 yaml 规范中删除 ServiceAccount。如果您从 yaml 规范中删除安装部分，这将保留 eksctl 创建的 iamserviceaccount。

1
2

apiVersion: v1
kind: ServiceAccount

应用 yaml 文件

`1`	`kubectl apply -f v2_3_1_full.yaml`

部署示例应用程序

将游戏 2048 部署为示例应用程序，以确认作为入口对象的结果，Amazon负载均衡器控制器是否会创建 Amazon ALB。

`1`	`kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.2.0/docs/examples/2048/2048_full.yaml`

几分钟后，验证是否已使用以下命令创建入口资源。

`1`	`kubectl get ingress/ingress-2048 -n game-2048`

输出：

1
2

NAME           CLASS    HOSTS   ADDRESS                                                                       PORTS   AGE
ingress-2048   <none>   *       k8s-game2048-ingress2-xxxxxxxxxx-yyyyyyyyyy.cn-north-1.elb.amazonaws.com.cn   80      3h42m

如果在几分钟后尚未创建入口，请运行以下命令以查看负载均衡器控制器日志。这些日志包含可帮助您诊断部署中任何问题的错误消息。

`1`	`kubectl logs -n kube-system deployment.apps/aws-load-balancer-controller`

打开浏览器并从上一命令输出导航到 ADDRESS URL 以查看示例应用程序。如果您没有看到任何内容，请等待几分钟，并刷新您的浏览器。

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211217431135/
相关话题：https://www.cnsre.cn/tags/aws/

Log4j 漏洞修复检测附检测工具

Wenlong — Sun, 12 Dec 2021 12:10:00 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211213210004/
相关话题：https://www.cnsre.cn/tags/log4j/

近日的Log4j2，可是非常的火啊，我也是加班加点把补丁给打上了次安心。Apache Log4j2存在远程代码执行漏洞，经验证，该漏洞允许攻击者在目标服务器上执行任意代码，可导致服务器被黑客控制。由于Apache Log4j 2应用较为广泛，建议使用该组件的用户尽快采取安全措施。

影响范围

漏洞影响版本：

2.0 <= Apache Log4j 2 <= log4j-2.15.0-rc1

漏洞描述

Apache Log4j 2是一个基于Java的日志记录工具，是对 Log4j 的升级。近日安恒信息应急响应中心监测到Apache Log4j 2存在远程代码执行漏洞，攻击者可通过构造恶意请求利用该漏洞实现在目标服务器上执行任意代码。

漏洞修复

由于Log4j2 作为日志记录基础第三方库，被大量Java框架及应用使用，只要用到 Log4j2 进行日志输出且日志内容能被攻击者部分可控，即可能会受到漏洞攻击影响。因此，该漏洞也同时影响全球大量通用应用及组件，例如：
Apache Struts2、Apache Solr、Apache Druid、Apache Flink、Apache Flume、Apache Dubbo、Apache Kafka、Spring-boot-starter-log4j2、ElasticSearch、Redis、Logstash等
建议及时检查并升级所有使用了 Log4j 组件的系统或应用。

紧急： 目前漏洞POC已被公开，官方已发布安全版本，建议使用该组件的用户尽快采取安全措施。

临时性缓解措施：

1、在 jvm 参数中添加 -Dlog4j2.formatMsgNoLookups=true
2、系统环境变量中将LOG4J_FORMAT_MSG_NO_LOOKUPS 设置为 true
3、创建 log4j2.component.properties 文件，文件中增加配置 log4j2.formatMsgNoLookups=true
4、若相关用户暂时无法进行升级操作，也可通过禁止Log4j中SocketServer类所启用的socket端对公网开放来进行防护
5、禁止安装log4j的服务器访问外网，并在边界对dnslog相关域名访问进行检测。部分公共dnslog平台如下

ceye.io
dnslog.link
dnslog.cn
dnslog.io
tu4.org
awvsscan119.autoverify.cn
burpcollaborator.net
s0x.cn

彻底修复漏洞：

建议您在升级前做好数据备份工作，避免出现意外
研发代码修复：升级到官方提供的 log4j-2.15.0-rc2 版本
https://github.com/apache/logging-log4j2/releases/tag/log4j-2.15.1-rc1

漏洞检测工具

检测工具下载地址 https://pan.cnsre.cn/d/Package/Linux/360log4j2.zip

漏洞检测

浏览器被动式扫描检测方案

原理
工程师可设置该代理通过浏览器被动扫描目标，查看 DNS Log 检测是否存在 log4j 漏洞。
使用方法
1.浏览器或操作系统配置 HTTP/HTTPS 代理：219.141.219.69:18080

2.浏览器或操作系统将下列证书添加到信任名单：附件sqli-hunter.pem

3.使用浏览器正常进行目标浏览，当结束扫描后，在http://219.141.219.69:18000/ 下检查是否存在以目标域名为名的 txt 文件，如 http://219.141.219.69/360.cn.txt

4.若存在，则说明目标网站存在漏洞，细节如下：

可看到完整 HTTP 请求细节，params参数为存在 log4j 注入漏洞的参数

使用限制

主机外网 IP 无法访问 360 IP，请不要使用该代理扫描 360
目前只能检测 POST body 中的参数
不允许任何恶意攻击

本地扫描常规检测方案

下载本地检测工具
扫描源码：./log4j-discoverer –src"源码目录"
扫描jar包：./log4j-discoverer–jar “jar包文件”
扫描系统进程：./log4j-discoverer –scan

Log4j漏洞补丁方案

如果检测到相关漏洞的应用或组件，建议立即对该应用或组件进行打补丁修复， Log4j补丁方案如下：

工具原理

Hook前受到log4j jndi注入攻击

执行 java -jar PatchLog4j.jar

打入补丁后 log4j不再处理JNDI逻辑直接将JNDI字符串输出

工具来源【360政企安服高攻实验室】

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211213210004/
相关话题：https://www.cnsre.cn/tags/log4j/

kubectl 彩色输出 -- kubecolor

Wenlong — Fri, 10 Dec 2021 09:52:58 +0800

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211210952578/
相关话题：https://www.cnsre.cn/tags/kubernetes/

kubecolor 是什么？

kubecolor 为您的kubectl命令输出着色，不执行任何其他操作。kubecolor 在内部调用kubectlcommand 并尝试对输出进行着色，以便你可以使用 kubecolor 作为 kubectl 的完整替代方案。

kubecolor项目地址

安装

通过 GitHub 发布下载

git clone https://github.com/dty1er/kubecolor.git

通过 go 命令手动构建

cd kubecolor/
go build -o kubecolor cmd/kubecolor/main.go

构建后，得到一个 kubecolor 的文件

设置默认 kubectl 使用 kubecolor

echo "alias kubectl='/root/kubecolor/kubecolor" >> ~/.bashrc
# 使配置生效
source .bashrc

效果展示

kubectl get pods

kubectl describe

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211210952578/
相关话题：https://www.cnsre.cn/tags/kubernetes/

kubernetes架构图

Wenlong — Wed, 08 Dec 2021 10:38:35 +0800

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211208038353/
相关话题：https://www.cnsre.cn/tags/kubernetes/

一、kubernetes 集群架构图

二、Openshift or Kubernetes 集群架构图

三、常见的 CI/CD 架构图

1、Gitlab Webhook + Jenkins SharedLibraries/Kubernetes + SonarScanner Maven Plugin

2、Gitlab CI/CD Workflow

3、Logging

4、Logging与Metrics

原文出处

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211208038353/
相关话题：https://www.cnsre.cn/tags/kubernetes/

AWS私有仓库ECR推送拉取镜像

Wenlong — Mon, 06 Dec 2021 09:44:18 +0800

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211206944174/
相关话题：https://www.cnsre.cn/tags/aws/

什么是 Amazon Elastic Container Registry（ECR）？

Amazon Elastic Container Registry (Amazon ECR) 是 Amazon 托管容器映像注册表服务，它安全、可扩展且可靠。Amazon ECR 支持私有存储库，其具有使用 Amazon IAM 的基于资源的权限。这样，指定用户或 Amazon EC2 实例可以访问您的容器存储库和映像。您可以使用首选 CLI 推送、提取和管理 Docker 映像、Open Container Itistry (OCI) 映像和 OCI 兼容构件。

Amazon ECR 的功能

Amazon ECR 提供以下功能：

生命周期策略有助于管理存储库中映像的生命周期。您可以定义导致清理未使用映像的规则。您可以在将规则应用到存储库之前对其进行测试。有关更多信息，请参阅生命周期策略。
映像扫描有助于识别容器映像中的软件漏洞。每个存储库都可以配置为在推送时扫描。这可确保扫描推送到存储库的每个新映像。然后，您可以检索映像扫描的结果。有关更多信息，请参阅映像扫描。
跨区域和跨账户复制使您可以更轻松地将映像放置在需要的位置。它配置为注册表设置，并基于每个区域。有关更多信息，请参阅私有注册表设置。

推送 Docker 映像到 Amazon ECR 存储库

我们可以使用 docker push 命令将容器映像推送到 Amazon ECR 存储库。Amazon ECR 还支持创建和推送用于多架构映像的 Docker 清单列表。清单列表中引用的每个映像都必须已经被推送到我们的存储库。

在推送映像之前，Amazon ECR 存储库必须存在。

向要向其推送映像的 Amazon ECR 注册表验证 Docker 客户端的身份。必须针对每个注册表获得授权令牌，令牌有效期为 12 小时。

要对 Amazon ECR 注册表验证 Docker，请运行 aws ecr get-login-password 命令。将身份验证令牌传递给 docker login 命令时，将值 AWS 用作用户名，并指定要对其进行身份验证的 Amazon ECR 注册表 URI。如果对多个注册表进行身份验证，则必须针对每个注册表重复该命令。

如果收到错误，请安装或更新到最新版本的 Amazon CLI。有关更多信息，请参阅 Amazon Command Line Interface 用户指南中的安装 Amazon Command Line Interface。

检索身份验证令牌并向注册表验证 Docker 客户端身份。

使用亚马逊云科技 CLI:

aws ecr get-login-password --region cn-north-1 | docker login --username AWS --password-stdin 12345678.dkr.ecr.cn-north-1.amazonaws.com.cn

如果您在使用亚马逊云科技 CLI 时遇到错误，请确保您已安装最新版本的亚马逊云科技 CLI 和 Docker。

构建 Docker 映像

如果您已生成映像，则可跳过此步骤:

docker build -t cnsre-test .

标记映像

生成完成后，标记您的映像，以便将映像推送到此存储库:

docker tag cnsre-test:latest 12345678.dkr.ecr.cn-north-1.amazonaws.com.cn/cnsre-test:latest

推送镜像

运行以下命令将此映像推送到新创建的亚马逊云科技存储库:

docker push 12345678.dkr.ecr.cn-north-1.amazonaws.com.cn/cnsre-test:latest

出现 Head https://registry-1.docker.io/v2/library/node/manifests/14-alpine 的解决方法

vim /etc/docker/daemon.json

# 添加国内的镜像 阿里云镜像 
{ "registry-mirrors":["https://6kx4zyno.mirror.aliyuncs.com"] }
# 或者中科院镜像
"registry-mirrors":["https://docker.mirrors.ustc.edu.cn"] }

重启Docker

systemctl daemon-reload 
systemctl restart docker

拉取镜像

使用 docker pull 命令提取映像。映像名称格式应为 registry/repository[:tag] 以便按标签拉取，或为 registry/repository[@digest] 以便按摘要拉取。

docker pull 12345678.dkr.ecr.cn-north-1.amazonaws.com.cn/cnsre-test:latest

如果您收到 repository-url not found: does not exist or no pull access 错误，您可能需要向 Amazon ECR 验证您的 Docker 客户端。有关更多信息，请参阅私有注册表身份验证。

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211206944174/
相关话题：https://www.cnsre.cn/tags/aws/

AWS EKS 添加IAM用户角色

Wenlong — Fri, 03 Dec 2021 09:31:50 +0800

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211203931498/
相关话题：https://www.cnsre.cn/tags/aws/

因为创建 Amazon EKS 集群时，IAM 用户或角色会自动在集群的 RBAC 配置中被授予 system:masters 权限。例如，IAM 用户或角色可以是创建集群的联合身份用户。如果使用不属于 aws-auth ConfigMap 的 IAM 用户或角色访问 Amazon EKS 控制台，则无法看到 Kubernetes 工作负载。也不会看到集群的概览详细信息。所以要向其他 AWS 用户或角色授予与集群交互的能力，您必须在 Kubernetes 中编辑 aws-auth ConfigMap。

因为部门有不通的角色，所以想基于不通的角色分配不同的权限，下面是记录添加一个对 EKS 只有只读权限的 AIM 用户。

如果您在运行 AWS 命令行界面 (AWS CLI) 命令时遇到错误，请确保您使用的是最新版的 AWS CLI。

为 IAM 用户或角色配置权限

要查找具有主要集群配置权限的集群创建者或管理员角色，请在 AWS CloudTrail 中搜索 CreateCluster API 调用。然后，检查此 API 调用的 UserIdentity 部分。
识别需要权限的 IAM 用户或角色。
确认已识别的 IAM 用户或角色有权在 AWS 管理控制台中查看所有集群的节点和工作负载。

使用 aws-auth ConfigMap 将 IAM 用户或角色映射到 RBAC 角色和组

在连接 Amazon EKS API 服务器之前，安装并配置最新版本的 AWS CLI。

获取 AWS CLI 用户或角色的配置：

 aws sts get-caller-identity

输出将返回 IAM 用户或角色的 Amazon 资源名称 (ARN)。例如：

{
    "UserId": "XXXXXXXXXXXXXXXXXXXXX",
    "Account": "XXXXXXXXXXXX",
    "Arn": "arn:aws:iam::XXXXXXXXXXXX:user/testuser"
}

确认 ARN 与具有主要集群配置访问权限的集群创建者或管理员相匹配。如果 ARN 与集群创建者或管理员不匹配，请联系集群创建者 aws-auth ConfigMap。

添加对 EKS 集群具有只读访问权限的 IAM 用户

要允许超级用户访问权限以对任何资源执行任何操作，请添加 system:masters 而非 system:bootstrappers 和 system:nodes。有关更多信息，请参阅 Kubernetes 网站上的默认角色和角色绑定。

创建 rbac.yaml

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: reader
rules:
- apiGroups: ["*"]
  resources: ["deployments", "configmaps", "pods", "secrets", "services"]
  verbs: ["get", "list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: reader
subjects:
- kind: Group
  name: reader
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: ClusterRole
  name: reader
  apiGroup: rbac.authorization.k8s.io

要添加 IAM 用户或角色，请完成以下步骤之一。

添加 IAM 用户到 mapUsers。

...
  mapUsers: |
    - userarn: arn:aws:iam::424432388155:user/developer
      username: developer
      groups: 
      - reader
...

创建 RBAC

kubectl apply -f rbac.yaml

在AWS 中创建 AmazonEKSDeveloperPolicy 策略以让用户在 AWS 管理控制台中查看所有集群的节点和工作负载

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "eks:DescribeNodegroup",
                "eks:ListNodegroups",
                "eks:DescribeCluster",
                "eks:ListClusters",
                "eks:AccessKubernetesApi",
                "ssm:GetParameter",
                "eks:ListUpdates",
                "eks:ListFargateProfiles"
            ],
            "Resource": "*"
        }
    ]
}

创建eks-developerIAM 组并附加AmazonEKSDeveloperPolicy策略
创建developer用户
添加developer个人资料aws configure --profile developer
添加到aws-authconfigmapdeveloper用户 ARN。

kubectl edit -n kube-system configmap/aws-auth
...
  mapUsers: |
    - userarn: arn:aws:iam::424432388155:user/developer
      username: developer
      groups: 
      - reader
...

为developer用户配置 kubectl 上下文

`1`	`aws eks --region us-east-1 update-kubeconfig --name eks --profile developer`

检查 kubeconfig

`1`	`kubectl config view --minify`

检查权限

1
2
3

kubectl auth can-i get pods
kubectl auth can-i create pods
kubectl run nginx --image=nginx

创建具有管理员访问权限的 IAM 角色并由 IAM 用户代入此角色。

创建AmazonEKSAdminPolicy策略

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "eks:*"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "*",
            "Condition": {
                "StringEquals": {
                    "iam:PassedToService": "eks.amazonaws.com"
                }
            }
        }
    ]
}

创建eks-admin角色并附加AmazonEKSAdminPolicy策略
描述eks-admin角色

`1`	`aws iam get-role --profile terraform --role-name eks-admin`

创建AmazonEKSAssumePolicy允许承担角色的策略

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "sts:AssumeRole"
            ],
            "Resource": "arn:aws:iam::424432388155:role/eks-admin"
        }
    ]
}

创建manager用户以使用eks-admin角色
添加manager个人资料aws configure --profile manager
检查manager用户是否可以承担eks-admin角色

`1`	`aws sts assume-role --role-arn arn:aws:iam::424432388155:role/eks-admin --role-session-name manager-session --profile manager`

为创建 EKS 集群的用户更新 kubeconfig

`1`	`aws eks --region us-east-1 update-kubeconfig --name eks --profile terraform`

添加到aws-authconfigmapeks-admin角色 ARN。

 kubectl edit -n kube-system configmap/aws-auth
...
- rolearn: arn:aws:iam::424432388155:role/eks-admin
  username: eks-admin
  groups:
  - system:masters
...

创建eks-admin配置文件以承担角色vim ~/.aws/config

[profile eks-admin]
role_arn = arn:aws:iam::424432388155:role/eks-admin
source_profile = manager

为manager用户配置 kubectl 上下文以自动承担eks-admin角色

`1`	`aws eks --region us-east-1 update-kubeconfig --name eks --profile eks-admin`

检查 kubeconfig

`1`	`kubectl config view --minify`

检查经理是否具有 EKS 集群的管理员访问权限

`1`	`kubectl auth can-i "" ""`

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211203931498/
相关话题：https://www.cnsre.cn/tags/aws/

Linux 大文件分割合并

Wenlong — Wed, 01 Dec 2021 09:55:42 +0800

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211201955418/
相关话题：https://www.cnsre.cn/tags/split/

1. 分割文件

文件分割可以使用split命令，该即支持文本文件分割，又支持二进制文件分割；而合并文件可以使用cat命令。

1.1 文本文件分割

分割文本文件时，可以按文件大小分割，也可以按文本行数分割。

按文件大小分割

按文件大小分割文件时，需要以-C参数指定分割后的文件大小：

$ split -C 100M large_file.txt stxt

如上所示，我们将大文件large_file.txt按100M大小进行分割，并指定了分割后文件前缀stxt；当不指定前缀时，split会自动对分割文件进行命名，一般会以x开头。

按行分割

文本文件还可以以行为单位进行分割，以行数进行分割时会忽略文件大小，并以-l参数指定分割后文件的行数：

$ split -l 1000 large_file.txt stxt

1.2 二进制文件分割

二进制文件分割类似于按大小分割文本文件，不同的是以-b参数来指定分割后的文件大小：

$ split -b 100M data.bak sdata

2. 文件合并

文件合并使用cat命令，上面几种方式分割的文件都可以使用cat命令合并。

cat命令合并分割文件：

$ cat stxt* > new_file.txt

3. 命令格式

3.1 `split`命令说明

split命令格式如下：

split [选项]... [要切割的文件 [输出文件前缀]]

命令参数

-a, --suffix-length=N   使用长度为 N 的后缀 (默认 2)
-b, --bytes=SIZE        设置输出文件的大小。支持单位：m,k
-C, --line-bytes=SIZE   设置输出文件的最大行数。与 -b 类似，但会尽量维持每行的完整性
-d, --numeric-suffixes  使用数字后缀代替字母
-l, --lines=NUMBER      设备输出文件的行数
    --help     显示版本信息
    --version  输出版本信息

3.2 `cat`命令说明

cat命令的常见使用场景有：

显示文件内容：

$ cat filename

创建一个空文件：

$ cat > filename

文件合并：

$ cat file1 file2 > file

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211201955418/
相关话题：https://www.cnsre.cn/tags/split/

Kubernetes 的 Taint 和 Toleration（污点和容忍）

Wenlong — Mon, 29 Nov 2021 09:46:48 +0800

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211129946481/
相关话题：https://www.cnsre.cn/kubernetes/

Taint 和 Toleration（污点和容忍）

在 k8s 集群中，节点亲和性 NodeAffinity 是一种 Pod 上定义的属性，能够让 Pod 可以按找我们的需求调度到指定节点上，而 Taints (污点) 则于NodeAffinity (节点亲和性)是相反的，它是一种 Node 上定义的属性，可以让 Pod 不被调度到带污点的节点上，甚至会对带污点节点上已有的 Pod 进行驱逐。对应的 k8s 可以给 Pod 设置 Tolerations(容忍) 让 Pod 能够对有污点的节点设置容忍，将 Pod 调度到该节点。 Taints 一般是配合 Tolerations 使用的。

为 node 设置污点和容忍

NoSchedule: 一定不能被调度
PreferNoSchedule: 尽量不要调度
NoExecute: 不仅不会调度, 还会驱逐Node上已有的Pod

为 node1 设置 taint：

1
2
3

kubectl taint nodes k8s-node1 key1=value1:NoSchedule
kubectl taint nodes k8s-node1 key1=value1:NoExecute
kubectl taint nodes k8s-node1 key2=value2:NoSchedule

查看 node1 上的 taint：

`1`	`kubectl describe nodes k8s-node1 \|grep Taint`

删除上面的 taint：

kubectl taint nodes k8s-node1 key1:NoSchedule-
kubectl taint nodes k8s-node1 key1:NoExecute-
kubectl taint nodes k8s-node1 key2:NoSchedule-
kubectl taint nodes k8s-node1 key1-     # 删除指定key所有的effect

为 pod 设置 toleration

只要在 pod 的 spec 中设置 tolerations 字段即可，可以有多个 key，如下所示：

tolerations:            
- key: "key1"          
  operator: "Equal"     
  value: "value1"       
  effect: "NoSchedule"  
- key: "key1"
  operator: "Equal"
  value: "value1"
  effect: "NoExecute"
- key: "node.alpha.kubernetes.io/unreachable"
  operator: "Exists"
  effect: "NoExecute"
  tolerationSeconds: 4000

tolerations 和 containers 同级。
key 能容忍的污点 key。
operator Equal 等于表示 key=value ， Exists 不等于，表示当值不等于下面 value 正常
value 可以设置为 NoSchedule、PreferNoSchedule 或 NoExecute。
effect effect 策略
tolerationSeconds 是当 pod 需要被驱逐时，可以继续在 node 上运行的时间。

具体的使用方法请参考官方文档。

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211129946481/
相关话题：https://www.cnsre.cn/tags/kubernetes/

k3s 卸载 traefik

Wenlong — Fri, 26 Nov 2021 10:03:07 +0800

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211126003074/
相关话题：https://www.cnsre.cn/tags/k3s/

安装了 k3s 以后，发现 traefik 并没有 ingress 用的习惯，于是我就打算吧 traefik 卸载了安装上ingress。

删除traefik

删除traefik舵图资源：

1
2

kubectl -n kube-system delete helmcharts.helm.cattle.io traefik
kubectl -n kube-system delete helmcharts.helm.cattle.io traefik-crd

修改 k3s.service 配置文件

停止k3s服务： systemctl stop k3s
编辑服务文件vim /etc/systemd/system/k3s.service并将此行添加到ExecStart ：
```
--disable traefik \
```
重新加载服务文件： systemctl daemon-reload
从自动部署文件夹中删除清单文件： rm /var/lib/rancher/k3s/server/manifests/traefik.yaml
启动k3s服务： systemctl start k3s

安装ingress

安装 ingress 的话参考我之前的文章 kubernetes 安装 ingress controller

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211126003074/
相关话题：https://www.cnsre.cn/tags/k3s/

zabbix-agent执行脚本提示：Permission denied

Wenlong — Wed, 24 Nov 2021 09:53:03 +0800

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211124953028/
相关话题：https://www.cnsre.cn/tags/zabbix/

故障表现

server端执行zabbix_get提示报错:没有权限

故障分析

zabbix自定义key监控日志

脚本如下

#!/bin/bash
Path=/home/xxx/logs/AspectLog/aspect.log

api1=xxxxxx/login

if [ $#  -ne 1 ];then
            echo "Follow the script name with an argument"
fi
case $1 in
        AccountLogin)
        cat $Path |grep  $api1 |awk -F ',' '{print $23}'|awk -F':' 'END {print $2}'
        ;;
        *)
        echo -e "\e[033mUsage: sh -bash [请输入API名称|如:AccountLogin]\e[0m"
esac

agent的配置文件

[root@ip-10-0-11-39 zabbix]# cat zabbix_agentd.conf |grep  usedtime.sh UserParameter=used.time[*],/etc/zabbix/usedtime.sh $1

server端执行zabbix_get提示报错:没有权限

[root@zabbix ~]# zabbix_get -s 10.0.10.243 -p 10050 -k usedtime.sh
{
     [cat: /home/ec2-user/homeconnect/logs/AspectLog/aspect.log
     : Permission denied
	]
}

故障分析

分析结果：agent端的selinux和firewalld已经关闭

通过zabbix_get 发现是因为 zabbix_agent 没有日志的权限。

解决方法

需要更改agent的配置文件

修改为 AllowRoot=1

重启agent 即可

systemctl  restart zabbix-agent

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211124953028/
相关话题：https://www.cnsre.cn/tags/zabbix/

10个 shell 常用脚本

Wenlong — Mon, 22 Nov 2021 08:46:49 +0800

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211122846494/
相关话题：https://www.cnsre.cn/tags/shell/

1、判断curl返回状态码

#!/bin/bash
response=$(curl -sL -o /dev/null -w %{http_code} https://baidu.com)
if [[ $response -ge 200 && $response -le 299 ]] ;then 
    echo 'check point success'
else 
    echo 'check point fail'
fi

2、读取文件中的配置到变量中

#!/bin/bash
# 配置文件中的配置项格式为key1=value1，一行一个配置项
while read line;do
    eval "$line"
done < /etc/openvpn/server/smtp.conf
echo $key1

3、根据console输入条件执行

#!/bin/bash
echo "选择以下功能:"
echo "   0) 功能0"
echo "   1) 功能1"
echo "   2) 功能2"
echo "   3) 功能3"
echo "   4) 功能4"
read -p "功能选项[4]: " option
until [[ -z "$option" || "$option" =~ ^[0-4]$ ]]; do
    read -p "$option为无效的选项，请重新输入功能选项: " option
done
case "$option" in
    0) 
        echo "功能0已执行!" 
    ;;
        1)
            echo "功能1已执行!" 
      exit
    ;;
        2)
            echo "功能2已执行!" 
            exit
        ;;
        3)
            echo "功能3已执行!"  
            exit
        ;;
        # 默认选项
        4|"")
            echo "功能4已执行!" 
            exit
        ;;
esac

4、将指定输出内容写入文件

{
echo "hahh"
echo "lalal"
} > /tmp/test

5、判断变量是否存在或为空

if [ -z ${var+x} ]; then 
    echo "var is unset"; 
else 
    echo "var is set to '$var'"; 
fi

6、换算秒为分钟、小时

#!/bin/bash

a=60100
swap_seconds ()
{
    SEC=$1
    (( SEC < 60 )) && echo -e "持续时间: $SEC秒\c"
    (( SEC >= 60 && SEC < 3600 )) && echo -e "持续时间: $(( SEC / 60 ))分钟$(( SEC % 60 ))秒\c"
    (( SEC > 3600 )) && echo -e "持续时间: $(( SEC / 3600 ))小时$(( (SEC % 3600) / 60 ))分钟$(( (SEC % 3600) % 60 ))秒\c"
}

b=`swap_seconds $a`
echo $b

输出

`1`	`持续时间: 16小时41分钟40秒`

7、脚本命令行参数的传递与判断

#!/bin/bash

main() {
    if [[ $# == 1 ]]; then
        case $1 in
        "-h")
            echo "脚本使用方法: "
            echo "  ./gitlab-pipeline.sh git仓库名1 git仓库名2 ... tag名(tag命名规则为: *-v加数字)"
            exit
            ;;
        "--help")
            echo "脚本使用方法: "
            echo "  ./gitlab-pipeline.sh git仓库名1 git仓库名2 ... tag名(tag命名规则为: *-v加数字)"
            exit
            ;;
        *)
            echo "参数错误！"
            exit
            ;;
        esac
    fi
}

main $*

8、检测docker 容器的启动状态

# 第一步：判断镜像是否存在
if [ `docker images --format {{.Repository}}:{{.Tag}} |grep -Fx 192.168.1.7:32772/applications/$CI_PROJECT_NAME:${CI_COMMIT_SHORT_SHA};echo $?` -eq 0 ];then
   docker pull 192.168.1.7:32772/applications/$CI_PROJECT_NAME:$CI_COMMIT_SHORT_SHA ;
fi;
# 第二步：判断是否已经有重名的容器在运行或者处在其他状态。重名的，先删掉，在启动；不重名的直接启动
if [ `docker ps -a --format {{.Names}} |grep -Fx $CI_PROJECT_NAME > /dev/null ;echo $?` -eq 0 ] ;then
   docker rm -f $CI_PROJECT_NAME ;
   docker run -d --name $CI_PROJECT_NAME -p 30088:8080 192.168.1.7:32772/applications/$CI_PROJECT_NAME:$CI_COMMIT_SHORT_SHA ;
else
   docker run -d --name $CI_PROJECT_NAME -p 30088:8080 192.168.1.7:32772/applications/$CI_PROJECT_NAME:$CI_COMMIT_SHORT_SHA ;
fi;
# 第三步：循环五次判断容器的监控检测是否处于什么状态。健康状态就直接退出循环，不健康显示健康检查日志，正在启动的直接显示。处于其他状态的直接显示状态
n=0;
while true ;do
  container_state=`docker inspect --format='{{json .State.Health.Status}}' $CI_PROJECT_NAME`;
  case $container_state in
    '"starting"' )
      echo "应用容器正在启动！";
    ;;
    '"healthy"' )
      echo "应用容器已启动，状态健康！";
    break;
    ;;
    '"unhealthy"' )
      echo "应用容器健康检测失败！";
      docker inspect --format='{{json .State.Health.Log}}' $CI_PROJECT_NAME;
    ;;
    * )
      echo "未知的状态:$container_state";
    ;;
  esac;
  sleep 1s;
  n=$(($n+1));
  if [ $n -eq 5 ];
     then break ;
  fi ;
done

9、检查常见系统命令是否安装

check_command() {
    if ! command -v ifconfig >/dev/null 2>&1; then
        echo -e "\033[31mifconfig命令不存在，正在下载安装！\033[0m"
        if os="ubuntu"; then
            apt install -y net-tools >/dev/null 2>&1
        elif os="centos"; then
            yum install -y net-tools >/dev/null 2>&1
        elif os="fedora"; then
            dnf install -y net-tools >/dev/null 2>&1
        fi
    elif ! command -v ip >/dev/null 2>&1; then
        echo -e "\033[31mip命令不存在，正在下载安装！\033[0m"
        if os="ubuntu"; then
            apt install -y iproute2 >/dev/null 2>&1
        elif os="centos"; then
            yum install -y iproute2 >/dev/null 2>&1
        elif os="fedora"; then
            dnf install -y iproute2 >/dev/null 2>&1
        fi
    elif ! command -v curl >/dev/null 2>&1; then
        echo -e "\033[31mcurl命令不存在，正在下载安装！\033[0m"
        if os="ubuntu"; then
            apt install -y curl >/dev/null 2>&1
        elif os="centos"; then
            yum install -y curl >/dev/null 2>&1
        elif os="fedora"; then
            dnf install -y curl >/dev/null 2>&1
        fi
    elif ! command -v wget >/dev/null 2>&1; then
        echo -e "\033[31mawk命令不存在，正在下载安装！\033[0m"
        if os="ubuntu"; then
            apt install -y wget >/dev/null 2>&1
        elif os="centos"; then
            yum install -y wget >/dev/null 2>&1
        elif os="fedora"; then
            dnf install -y wget >/dev/null 2>&1
        fi
    elif ! command -v tail >/dev/null 2>&1; then
        echo -e "\033[31mcoreutils命令不存在，正在下载安装！\033[0m"
        if os="ubuntu"; then
            apt install -y coreutils >/dev/null 2>&1
        elif os="centos"; then
            yum install -y coreutils >/dev/null 2>&1
        elif os="fedora"; then
            dnf install -y coreutils >/dev/null 2>&1
        fi
    elif ! command -v sed >/dev/null 2>&1; then
        echo -e "\033[31msed命令不存在，正在下载安装！\033[0m"
        if os="ubuntu"; then
            apt install -y sed >/dev/null 2>&1
        elif os="centos"; then
            yum install -y sed >/dev/null 2>&1
        elif os="fedora"; then
            dnf install -y sed >/dev/null 2>&1
        fi
    elif ! command -v grep >/dev/null 2>&1; then
        echo -e "\033[31mgrep命令不存在，正在下载安装！\033[0m"
        if os="ubuntu"; then
            apt install -y grep >/dev/null 2>&1
        elif os="centos"; then
            yum install -y grep >/dev/null 2>&1
        elif os="fedora"; then
            dnf install -y grep >/dev/null 2>&1
        fi
    fi
}

10、检查系统网络

check_network() {
    check_command
    ping -c 4 114.114.114.114 >/dev/null
    if [ ! $? -eq 0 ]; then
        echo -e "\033[31mIP地址无法ping通，请检查网络连接！！！\033[0m"
        exit
    fi
    ping -c 4 www.baidu.com >/dev/null
    if [ ! $? -eq 0 ]; then
        echo -e "\033[31m域名无法Ping通，请检查DNS配置！！！\033[0m"
        exit
    fi
    curl -s --retry 2 --connect-timeout 2 www.baidu.com >/dev/null
    if [ ! $? -eq 0 ]; then
        echo -e "\033[31m域名无法Ping通，请检查DNS配置！！！\033[0m"
        exit
    fi
}

原文出处：https://gitbook.curiouser.top/origin/bash-scirpts.html#

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211122846494/
相关话题：https://www.cnsre.cn/tags/shell/

快速搭建 kvm web 管理工具 WebVirtMgr

Wenlong — Wed, 17 Nov 2021 09:37:18 +0800

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211117937177/
相关话题：https://www.cnsre.cn/tags/kvm/

WebVirtMgr是近两年来发展较快，比较活跃，非常清新的一个KVM管理平台，提供对宿主机和虚机的统一管理，它有别于kvm自带的图形管理工具（virtual machine manager），让kvm管理变得更为可视化，对中小型kvm应用场景带来了更多方便。

WebVirtMgr介绍

WebVirtMgr采用几乎纯Python开发，其前端是基于Python的Django，后端是基于Libvirt的Python接口，将日常kvm的管理操作变的更加的可视化。

WebVirtMgr 特点

操作简单，易于使用、通过libvirt的API接口对kvm进行管理、提供对虚拟机生命周期管理

WebVirtMgr 功能

宿主机管理支持以下功能、CPU利用率、内存利用率、网络资源池管理、存储资源池管理、虚拟机镜像、虚拟机克隆、快照管理、日志管理、虚机迁移、虚拟机管理支持以下功能、CPU利用率、内存利用率、光盘管理、关/开/暂停虚拟机、安装虚拟机、VNC console连接、创建快照

官方文档

https://github.com/retspen/webvirtmgr/wiki/Install-WebVirtMgr

安装前的部署

安装一些依赖包

`1`	`yum -y install git python-pip libvirt-python libxml2-python python-websockify supervisor nginx gcc python-devel wget vim net-tools lrzsz`

安装pip

1
2
3

wget https://bootstrap.pypa.io/get-pip.py 
python get-pip.py 
pip -V

`1`	`pip install numpy`

安装python的需要包和配置Django环境

`1`	`git clone git://github.com/retspen/webvirtmgr.git`

安装nginx

1
2

rpm -Uvh http://nginx.org/packages/centos/7/noarch/RPMS/nginx-release-centos-7-0.el7.ngx.noarch.rpm 
yum install nginx -y

安装supervisor

安装参考

https://www.2cto.com/kf/201712/702837.html

开机自启参考

https://blog.csdn.net/binggoogle/article/details/53203991

`1`	`cat /etc/supervisord.conf`

⚠️ 注意

如果没有这个文件按照一下步骤安装

有的话忽略此步骤

1
2
3

pip install supervisor
mkdir /etc/supervisord.d/
echo_supervisord_conf > /etc/supervisord.conf

新建文件夹

`1`	`vim /etc/supervisord.d/app.conf`

配置文件 app.conf

内容为

[program:appname]
command=/root/soft/push.api
directory=/root/soft/push.api
autostart=true
autorestart=true
user=root
stdout_logfile = /var/log/supervisor/pushapi.log
stderr_logfile = /var/log/supervisor/pushapi-error.log

修改在配置文件最下方修改为

1
2
3

vim  /etc/supervisord.conf
[include]
files = /etc/supervisord.d/*.ini

1
2
3

supervisord -c /etc/supervisord.conf
/usr/bin/supervisorctl start all
/usr/bin/supervisorctl stop all

安装环境

1
2

cd webvirtmgr 
pip install -r requirements.txt

`1`	`./manage.py syncdb`

创建用户

输入以下用户信息

You just installed Django's auth system, which means you don't have any superusers defined.
Would you like to create one now? (yes/no): yes
Username (leave blank to use 'root'): admin
Email address: 275301281@qq.com
Password: admin
Password (again):admin 
Superuser created successfully.
Installing custom SQL ...
Installing indexes ...
Installed 6 object(s) from 1 fixture(s)
./manage.py collectstatic

配置一个超级用户

`1`	`./manage.py createsuperuser`

WARNING:root:No local_settings file found.
Username (leave blank to use 'root'): yes
Email address: 275301281@qq.com
Password: Lenovo@123
Password (again): Lenovo@123
Superuser created successfully.

设置nginx

a、使用:8000端口

移动这个 `webvirtmgr` 目录到 `/var/www` 下

1
2

cd  ..
mv webvirtmgr /var/www/

⚠️ 注意：
webvirtmgr 目录下还有一个名称为webvirtmgr 的文件夹
不要单独移动 webvirtmgr/webvirtmgr 文件

编辑配置文件

vim /etc/nginx/conf.d/webvirtmgr.conf

server {
    listen 80 default_server;

    server_name $hostname;
    #access_log /var/log/nginx/webvirtmgr_access_log; 

    location /static/ {
        root /var/www/webvirtmgr/webvirtmgr; # or /srv instead of /var
        expires max;
    }

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-for $proxy_add_x_forwarded_for;
        proxy_set_header Host $host:$server_port;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_connect_timeout 600;
        proxy_read_timeout 600;
        proxy_send_timeout 600;
        client_max_body_size 1024M; # Set higher depending on your needs 
    }
}

启动nginx并设置开机自启动

(如果不设置开机自启动，重启服务器supervisor无法管理Django进程)，并开机自启动supervisord

`1`	`/etc/init.d/nginx start`

或者

1
2

systemctl restart   nginx 
systemctl enable supervisord

分配权限

`1`	`chown nginx.nginx /var/www/webvirtmgr`

设置supervisor

在/etc/supervisord.conf末尾加入下面的配置：

vi /etc/supervisord.conf


[program:webvirtmgr]
command=/usr/bin/python /var/www/webvirtmgr/manage.py run_gunicorn -c /var/www/webvirtmgr/conf/gunicorn.conf.py
directory=/var/www/webvirtmgr
autostart=true
autorestart=true
logfile=/var/log/supervisor/webvirtmgr.log
log_stderr=true
user=nginx

[program:webvirtmgr-console]
command=/usr/bin/python /var/www/webvirtmgr/console/webvirtmgr-console
directory=/var/www/webvirtmgr
autostart=true
autorestart=true
#stdout_logfile=/var/log/supervisor/webvirtmgr-console.log
redirect_stderr=true
user=nginx

⚠️ 注意

进程无法启动或者报错可以选择吧 log 注释取消

重启supervisord

开机自启参考

https://blog.csdn.net/binggoogle/article/details/53203991

设置完之后重启即可

1
2
3

systemctl restart  supervisord.service
systemctl enable  supervisord.service
systemctl status   supervisord.service

更新

`1`	`cd /var/www/webvirtmgr git pull`

`1`	`./manage.py collectstatic`

`1`	`systemctl restart supervisord`

如果有错误或不运行

 ./manage.py runserver 0:8000
#或者后台运行脚本
nohup python  /var/www/webvirtmgr/manage.py runserver 0:8000  >/dev/null &
nohup python  /var/www/console/webvirtmgr-console   >/dev/null &

访问：http://x.x.x.x:8000(x.x.x.x - your server IP address )，输入创建的用户和密码，如果没有创建，请用python manager.py createsuperuser,命令创建。登录后如下图所示

配置虚拟机所在宿主机

webvirtmgr客户端就这样搭建完了，接下来需要配置虚拟机所在宿主机的，参考git地址.

配置宿主机

下载并执行脚本

如果虚拟机比较多，该脚本执行时间会比较长，因为会执行 service libvirt-guests restart，会将所有运行的虚拟机挂起然后再恢复，感觉这一步不是必须的，因为我有一台只设置ssh认证，也可以正常连接。

`1`	`curl http://retspen.github.io/libvirt-bootstrap.sh \| sudo sh`

如果没有curl就用wget

`1`	`wget -O - http://retspen.github.io/libvirt-bootstrap.sh \| sudo sh`

配置防火墙

`1`	`iptables -I INPUT -m state --state NEW -m tcp -p tcp --dport 16509 -j ACCEPT`

设置TCP授权

参考：https://github.com/retspen/webvirtmgr/wiki/Setup-TCP-authorization

webvirtmgr新建服务器连接时需要此账号

用saslpasswd2命令给libvirt的用户cnsre设置密码

1
2
3

saslpasswd2 -a libvirt cnsre
Password: cnsre
Again (for verification): cnsre

生成一个密码库

1
2
3

sasldblistusers2 -f /etc/libvirt/passwd.db 

cnsre@webvirtmgr.cn: userPassword

设置ssh授权

`1`	`ssh-keygen -t rsa # 产生公私钥`

直接回车，回车，回车

`1`	`ssh-copy-id 192.168.1.120`

⚠️ 注意

由于这里webvirtmgr和kvm服务部署在同一台机器，所以这里本地信任。

如果kvm部署在其他机器，那么这个是其他它的ip 同时也要设置ssh key密钥

提示输入密码的时候直接输入之前1.120的密码

`1`	`ssh 192.168.1.120 -L localhost:8000:localhost:8000 -L localhost:6080:localhost:6080`

web 平台加入其他kvm宿主机

在部署web管理的主机上执行命令

`1`	`ssh-keygen -t rsa`

然后在执行

`1`	`ssh-copy-id 192.168.1.165`

添加新的kvm宿主机

查看新加的kvm宿主机状态看有无报错

删除新加的账号

`1`	`sudo saslpasswd2 -a libvirt -d cnsre`

确认验证新加的账号配置

virsh -c qemu+tcp://IP_address/system nodeinfo
(virsh -c qemu+tcp://192.168.1.50/system nodeinfo)
Please enter your authentication name: cnsre
Please enter your password: xxxxxx
CPU model:           x86_64
CPU(s):              2
CPU frequency:       2611 MHz
CPU socket(s):       1
Core(s) per socket:  2
Thread(s) per core:  1
NUMA cell(s):        1
Memory size:         2019260 kB

⚠️ 注意

账号全名带hostname，如 cnsre@webvirtmgr.cn

测试的时候这一步测试没有成功但是可以链接

设置ssh认证

ssh和tcp设置一种即可，其实就是设置无密码登录，要注意的是从webvirtmgr的什么用户到宿主机的什么用户的无密码登录，比如我用root跑的django webvirtmgr，而宿主机也是root跑的virsh，所以需要设置root到root的无密码登录。而git官网推荐的是用nginx用户跑django webvirtmgr，webvirtmgr用户跑的virsh，所以设置的是nginx用户到宿主机webvirtmgr用户的无密码登录。

参考：https://github.com/retspen/webvirtmgr/wiki/Setup-SSH-Authorizatio

使用tcp认证连接服务器

访问：http://192.168.1.120:8000，xxxx是webvirtmgr的ip地址，点击new connection

填写kvm宿主机的一些信息

基础架构可以看到一些vm虚拟机

KVM WEB管理常见报错

网页控制台远程链接报错1006

安装vnc即可

`1`	`yum install -y novnc`

网页控制台远程链接报错505

1
2

cd /var/www/console/
./webvirtmgr-console  &

后台运行脚本

1
2

nohup python  /var/www/webvirtmgr/manage.py runserver 0:8000  >/dev/null & 
nohup python  /var/www/console/webvirtmgr-console   >/dev/null &

其他web管理 webvirtcloud

webvirtcloud 的作者还是 webvirtmgr的作者，但是 webvirtmgr 已经有好久没有维护了。如果你想体验 webvirtcloud 你可以安装webvirtcloud。

webvirtcloud 特征

QEMU/KVM 管理程序管理
QEMU/KVM 实例管理 - 创建、删除、更新
虚拟机管理程序和实例基于 Web 的统计信息
管理多个 QEMU/KVM 管理程序
管理管理程序数据存储池
管理管理程序网络
使用浏览器访问实例控制台
基于 Libvirt API 的 Web 管理 UI
基于用户的授权和认证
用户可以在实例中将 SSH 公钥添加到 root（仅测试 Ubuntu）
用户可以在实例中更改 root 密码（仅测试 Ubuntu）
支持 cloud-init 数据源接口
webvirtcloud具体文档请查看 webvirtcloud 项目

webvirtcloud 的作者也贴心的提供了一键脚本

1
2
3

wget https://raw.githubusercontent.com/retspen/webvirtcloud/master/install.sh 
chmod 744 install.sh #以 sudo 或 root 用户运行
./install.sh

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211117937177/
相关话题：https://www.cnsre.cn/tags/kvm/

kvm简单使用

Wenlong — Mon, 15 Nov 2021 09:03:26 +0800

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211115903260/
相关话题：https://www.cnsre.cn/tags/kvm/

virsh命令常用参数

参数	参数说明
基础操作
list	查看虚拟机列表，列出域
start	启动虚拟机，开始一个（以前定义的）非活跃的域
shutdown	关闭虚拟机，关闭一个域
destroy(危险)	强制关闭虚拟机，销毁（停止）域
vncdisplay	查询虚拟机vnc端口号
配置管理操作
dumpxml	导出主机配置信息
undefine	删除主机
define	导入主机配置
domrename	对虚拟机进行重命名
挂起与恢复
suspend	挂起虚拟机
resume	恢复虚拟机
自启动管理
autostart	虚拟机开机启动
autostart –disable	取消虚拟机开机启动
以上参数通过 “virsh –help” 获得。

删除虚拟机

virsh destroy njvm01     #强制关闭电源

virsh undefine njvm01   #删除虚拟机

[root@nkgtsv01 data]# virsh shutdown njvm01

域 njvm01 被关闭

[root@nkgtsv01 data]# virsh start njvm01

域 njvm02 已开始

[root@nkgtsv01 data]# virsh list --all   查看虚拟机状态

设置虚拟机自启动

1
2
3

virsh autostart njvm01

virsh autostart --disable njvm02

启动，关闭和重启一个虚拟机

virsh start njvm01

virsh shutdown njvm01

virsh reboot njvm01

宿主机链接到kvm虚拟机

`1`	`virsh console njvm01`

克隆虚拟机

`1`	`virt-clone -o njvm01-n njvm02-f /data/kvm-img/njvm02.img`

修改njvm05 配置

`1`	`virsh edit njvm01`

挂起及恢复虚拟机

挂起：

virsh suspend njvm01

恢复：

virsh resume njvm01

创建KVM linux

virt-install --name njvm01 --boot network,cdrom,menu=on --ram 8000 --vcpus=2 --os-variant=rhel6 --accelerate --cdrom=/home/iso/CentOS-7-x86-64-DVD-1708.iso --disk path=/data/kvm-i/njvm01.img,size=200,bus=virtio --bridge=br0,model=virtio --autostart --vnc --vncport=5930 --vnclisten=0.0.0.0

创建KVM Windows

virt-install --name njvmwin --boot network,cdrom,menu=on --ram 6411 --os-type=windows --vcpus=1 --os-variant=rhel6 --accelerate --cdrom=/data/BBackup/  --disk path=/data/kvm-images/njvmwin.img,size=200,bus=virtio --bridge=br0, --autostart --vnc --vncport=5910 --vnclisten=0.0.0.0


virt-install -n njvmwin --vcpus=1 --ram=6411--os-type=windows --os-variant=win2k8 -c /vm/iso/cn_windows_server_2012_r2_sp1_x64.iso --disk path=/usr/share/virtio-win/virtio-win-0.1.126_amd64.vfd,device=floppy --disk path=/vm/win2012.img,format=qcow2,bus=virtio --graphics vnc,listen=0.0.0.0 --noautoconsole

vm添加vnc端口

https://www.cnblogs.com/chenjiahe/p/5919742.html

<graphics type='vnc' port='5900' autoport='no' listen='0.0.0.0'>

  <listen type='address' address='0.0.0.0'/>

 </graphics>

注意

要用 virsh edit vi命令不会生效

--name njvm01 \                    #虚拟机名

--ram=1024 \                      #分配内存大小，MB

--vcpus=1 \                       #配置虚拟机的vcpu 数目

--check-cpu \                     #检查确定vcpu是否超过物理 CPU数目，如果超过则发出警告。

--os-type=linux \                  #要安装的操作系统类型，例如：'linux'、'unix'、'windows'

--os-variant=rhel6 \               #操作系统版本，如：'Fedora6', 'rhel5', 'solaris10',  'win2k'

--disk path=/virhost/node7.img,device=disk,bus=virtio,size=20,sparse=true \  #虚拟  机所用磁盘或镜像文件，size大小G

--bridge=br0 \                     #指定网络，采用透明网桥

--noautoconsole \                  #不自动开启控制台

--pxe                              #网络安装

 virsh start njvm01                 #开机

 virsh destroy njvm01               #强制关闭电源

 virsh shutdown njvm01              #关机

 virsh list --all                  #查看虚拟机状态  

 virsh reboot njvm01                #重启
 
 virt-viewer name                   #查看安装状态

xml文件详解

使用virt-install 工具安装虚拟机后，在目录 /etc/libvirt/qemu/ 下生成 xml 配置文件

 <domain type='kvm'>        # 虚拟机类型

   <name>centos</name>                  虚拟机名称

   <uuid>78dx24ef-1d2d-810x-9213-2c02df529cx</uuid>   uuid唯一标示

   <memory unit='KiB'>2048576</memory>          指定虚拟机内存大小，给出了单位

   <vcpu placement='static'>2</vcpu>           虚拟机占用虚拟cpu个数，这里指物理cpu的核心数量

   <os>

    <type arch='x86_64' machine='rhel6.3.0'>hvm</type>  指定虚拟系统架构

    <boot dev='hd'/>                   启动类型，从硬盘启动

   </os>

   <devices>

    <emulator>/usr/libexec/qemu-kvm</emulator>      驱动程序，同上，使用的是qemu-kvm

    <disk type='file' device='disk'>           指定磁盘类型

    <driver name='qemu' type='raw' cache='none'/>    指定磁盘格式，这里是raw，也支持qcow2.

    <source file='/home/data/img/centos.img'/>        img文件路径

    <target dev='hda' bus='ide'/>            磁盘文件标示，驱动类型

    <address type='drive' controller='0' bus='0' target='0' unit='0'/>

    <interface type='bridge'>

     <mac address='34:72:00:15:65:e6'/>         自动生成，可以手动指定。

     <source bridge='br0'/>               桥接到哪一个接口

    </interface>

   </devices>

 </domain>

列出虚拟机的所有网口

virsh domiflist njvm01

结果如下：

Interface Type    Source   Model    MAC ------------------------------------------------------- vnet0   bridge   br0   virtio   34:72:00:15:65:e6 vnet1   bridge   br1   virtio   52:54:10:f5:c5:6c

新增一个网口

virsh attach-interface domain --type bridge --source br1 --model virtio --config           # 下次启动生效

virsh attach-interface domain --type bridge --source br1 --model virtio --current          # 立即生效

virsh detach-interface domain --type bridge --mac 34:72:00:15:65:e6 --config               # 下次启动生效

virsh detach-interface domain --type bridge --mac 34:72:00:15:65:e6 --current              # 立即生效

删除网卡命令

`1`	`virsh detach-interface njvm01 --type network --mac 34:72:00:15:65:e6`

永久添加网卡

`1`	`virsh attach-interface domain --type network --source default --model virtio --config`

临时添加网卡

virsh attach-interface njvm01 --type network --source default

virsh attach-interface njvm01  --type network --source default --config

关闭或打开某个网口

1
2
3

virsh domif-setlink domain vnet0 down

virsh domif-setlink domain vnet0 up

获取某个网口状态

`1`	`virsh domif-getlink win2k8 vnet1`

列出所有的块设备

`1`	`virsh domblklist win2k8`

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211115903260/
相关话题：https://www.cnsre.cn/tags/kvm/

一键安装java、tomcat脚本

Wenlong — Fri, 12 Nov 2021 08:39:38 +0800

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211112839379/
相关话题：https://www.cnsre.cn/tags/shell/

前言

最近有几台新上的设备，需要安装jdk和tomcat。为了避免以后这种重复的劳动力，我决定写一个脚本，直接执行脚本就可以自动选择你安装的jdk以及tomcat的脚本，来避免这种问题。

脚本内容

此脚本只针对于centos7完成测试，其他版本未测试。使用时请注意。
脚本内容如下

#!/bin/bash
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
LANG=en_US.UTF-8

RD="\033[31m"      # 错误消息
GR="\033[32m"      # 成功消息
YL="\033[33m"      # 告警消息
BL="\033[36m"      # 日志消息
PL='\033[0m'

clear
echo -e "${YL}##################################################${PL}"
echo -e "${YL}#${PL}${GR}脚本名称${PL}: 一键安装java、tomcat脚本              ${YL}#${PL}"
echo -e "${YL}#${PL}${GR}作    者${PL}: sre运维博客                           ${YL}#${PL}"
echo -e "${YL}#${PL}${GR}网    址${PL}: www.cnsre.cn                          ${YL}#${PL}"
echo -e "${YL}#${PL}${GR}文章地址${PL}: https://cnsre.cn/posts/211112839379/  ${YL}#${PL}"
echo -e "${YL}##################################################${PL}"
sleep 0.5

echo -e "${RD}本脚本将会自动安装1.8.0_221版本jdk以及8.5.23版本tomcat，请确认是否安装？${PL}"
read -r -p "确定请按 y 任意键则退出！请选择：[y/n]" input
    if [[ $input != "y" ]]; then
        exit 1
    else
        echo -e "${GR}正在下载java tomcat安装包,请稍后${PL}"
    fi
wget -q -c  https://pan.cnsre.cn/d/Package/Linux/jdk/tomcat-8.5.23_jdk1.8.0_221.tar.gz
tar -zxf  tomcat-8.5.23_jdk1.8.0_221.tar.gz
sleep 0.5

echo -e "${RD}是否确定安装 1.8.0_221 版本 jdk? ${PL}"
read -r -p "确定请按 y 任意键则退出！请选择：[y/n]" input
    if [[ $input != "y" ]]; then
        exit 1
    else 
        echo -e "${GR}你已经选择安装1.8.0_221版本 jdk${PL}"
    fi
read -r -p "请选择安装jdk的绝对路径，请不要输入最后的"/":" input

if [ ! -d $input ]; then
  echo -e "${RD}你输入的路径不存在，请重新输入或者创建后再次执行脚本${PL}"
  exit 1
fi

echo -e "${GR}正在安装 1.8.0_221 版本 jdk${PL}"
mv jdk1.8.0_221 $input/jdk

cat << EOF >> /etc/profile 
############## JAVA ##############
export JAVA_HOME=$input/jdk
export JAVA_BIN=$JAVA_HOME/bin
export JAVA_LIB=$JAVA_HOME/lib
export CLASSPATH=.:$JAVA_LIB/tools.jar:$JAVA_LIB/dt.jar
export PATH=$JAVA_BIN:$PATH
EOF




echo -e "${GR}验JAVA home及版本${PL}"
sleep 2
chmod +x $input/jdk/bin/java
chmod +x $input/jdk/jre/bin/java
source /etc/profile
echo -e"${GR}你的java安装路径为：$JAVA_HOME ${PL}"
java  -version


echo -e "${RD}是否确定安装 8.5.23  版本 tomcat ? ${PL}"
read -r -p "确定请按 y 任意键则退出！请选择：[y/n]" input
    if [[ $input != "y" ]]; then
        exit 1
    else
        echo -e "${GR}你已经选择安装 8.5.23 版本 tomcat ${PL}"
    fi
read -r -p "请选择安装tomcat的绝对路径，请不要输入最后的"/":" input

if [ ! -d $input ]; then
  echo -e "${RD}你输入的路径不存在，请重新输入或者创建后再次执行脚本${PL}"
  exit 1
fi

echo -e "${GR}正在安装 8.5.23 版本 tomcat${PL}"
mv apache-tomcat-8.5.23  $input/tomcat

chmod +x $input/tomcat/bin/*.sh

echo -e "${GR}正在将tomcat加入系统服务${PL}"
sleep 2
touch /usr/lib/systemd/system/tomcat.service
cat << EOF >> /usr/lib/systemd/system/tomcat.service
[Unit]  
Description=Tomcat
After=syslog.target network.target remote-fs.target nss-lookup.target  

[Service]  
Type=forking  

ExecStart=$input/tomcat/bin/startup.sh
ExecReload=$input/tomcat/bin/startup.sh
ExecStop=$input/tomcat/bin/shutdown.sh

[Install]
WantedBy=multi-user.target
EOF
sed -i '2i\export JAVA_HOME='$JAVA_HOME'' $input/tomcat/bin/catalina.sh

systemctl  daemon-reload
systemctl  restart tomcat.service
systemctl  status  tomcat.service

echo -e "${RD}请确认是否选择开机启动tomcat ? ${PL}"
read -r -p "确定请按 y 任意键则退出！请选择：[y/n]" input
    if [[ $input != "y" ]]; then
        systemctl  disable  tomcat.service
        echo -e "${GR}已为你关闭tomcat开机启动 ${PL}"
    else
        systemctl  enable  tomcat.service
        echo -e "${GR}已为你开启tomcat开机启动 ${PL}"
    fi

echo -e "${YL}==================================================================${PL}"
echo -e "${GR}tomcat部署完成并启动${PL}"
echo -e "${YL}==================================================================${PL}"
echo -e "${GR}外网tomcat地址: http://$(curl -sS --connect-timeout 10 -m 60 cip.cc |grep IP|awk -F ':[ ]' '{print $2}'):8080${PL}"
echo -e "${GR}内网tomcat地址: http://$(ip addr | grep -E -o '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | grep -E -v "^127\.|^255\.|^0\." | head -n 1):8080${PL}"
echo -e "${GR}你可以通过以下命令来管理tomcat服务${PL}"
echo -e "${GR}启动tomcat服务：systemctl  start tomcat.service${PL}"
echo -e "${RD}停止tomcat服务：systemctl  stop tomcat.service${PL}"
echo -e "${YL}重启tomcat服务：systemctl  restart tomcat.service${PL}"
echo -e "${GR}若无法访问tomcat，请检查防火墙/安全组是否有放行tomcat 8080 端口${PL}"
echo -e "${GR}==================================================================${PL}"

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211112839379/
相关话题：https://www.cnsre.cn/tags/shell/

k3s单机版安装部署附一键安装脚本

Wenlong — Tue, 09 Nov 2021 09:07:03 +0800

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211109907029/
相关话题：https://www.cnsre.cn/tags/k3s/

双十一各大云厂商纷纷撒种子种韭菜（抢用户），良心云 也是一如既往的良心，新用户更是通过某宝 148 就可以买到三年 2C4G8M 的轻量应用服务器。于是我也出售薅了羊毛入手了一台。
但是对于各种组件本身就对资源消耗比较大的 k8s 来说，跑起来还是有点费力的，于是我打算将这台实例部署一台轻量级的 Kubernetes: k3s

k8s VS k3s

k3s 是 Rancher 推出的轻量级 k8s。k3s 本身包含了 k8s 的源码，而二进制包却只有 60M 但是本质上和 k8s 没有区别。但为了降低资源占用，k3s 和 k8s 还是有一些区别的，主要是：

使用了相比 Docker 更轻量的 containerd 作为容器运行时（Docker 并不是唯一的容器选择）。
去掉了 k8s 的 Legacy, alpha, non-default features。
用 sqlite3 作为默认的存储，而不是 etcd。
其他的一些优化，最终 k3s 只是一个 binary 文件，非常易于部署。、

所以 k3s 适用于边缘计算，IoT 等资源紧张的场景。同时 k3s 也是非常容易部署的，官网上提供了一键部署的脚本。

k3s的优点

k3s将安装Kubernetes所需的一切打包进仅有60MB大小的二进制文件中，并且完全实现了Kubernetes API。为了减少运行Kubernetes所需的内存，Rancher删除了很多不必要的驱动程序，并用附加组件对其进行替换。
k3s是一款完全通过CNCF认证的Kubernetes发行版，这意味着你可以编写YAML来对完整版的Kubernetes进行操作，并且它们也将适用于k3s集群。
由于它只需要极低的资源就可以运行，因此它能够在任何512MB RAM以上的设备上运行集群，换言之，我们可以让pod在master和节点上运行。

k3s的缺点

首先，当前k3s的版本（k3s v0.8.1）仅能运行单个master，这意味着如果你的master宕机，那么你就无法管理你的集群，即便已有集群要继续运行。但是在k3s v0.10的版本中，多主模式已经是实验性功能，也许在下一个版本中能够GA。
其次，在单个master的k3s中，默认的数据存储是SQLite，这对于小型数据库十分友好，但是如果遭受重击，那么SQLite将成为主要痛点。但是，Kubernetes控制平面中发生的更改更多是与频繁更新部署、调度Pod等有关，因此对于小型开发/测试集群而言，数据库不会造成太大负载。

结论

K8s和k3s各有优劣，使用场景也有所区别，因此不能一概而论。如果你要进行大型的集群部署，那么我建议你选择使用K8s；

如果你像我一样只是为了开发或者测试，那么选择k3s则是性价比更高的选择。

安装 k3s

确保你是一台干净的 CentOS7 服务器。
按照惯例先更新,更新前顺便把源换为国内的yum源。

# 改国内yum源
curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
curl -o /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
# 更新
yum update -y

修改主机名

`1`	`hostnamectl set-hostname k3s-master`

修改完毕后，断开重连一下。

⚠️ 注意
K3s 默认将使用 containerd 作为容器环境，请在下边选择 使用Docker安装 或者使用Containerd安装。

使用 docker 安装

# 安装 docker-ce
yum remove -y docker docker-client docker-client-latest docker-common docker-latest docker-latest-logrotate docker-logrotate docker-engine
yum install -y yum-utils
yum-config-manager --add-repo  https://download.docker.com/linux/centos/docker-ce.repo
yum install -y docker-ce docker-ce-cli containerd.io
# 解决内核检查问题 重启生效
grubby --args="user_namespace.enable=1" --update-kernel="$(grubby --default-kernel)"
systemctl enable docker
systemctl start docker
# 修改 docker 源
cat << EOF > /etc/docker/daemon.json
{
    "registry-mirrors":["https://3laho3y3.mirror.aliyuncs.com"]
}
EOF
systemctl daemon-reload
systemctl restart docker
# 安装 docker 结束
# 关 firewalld 防火墙
systemctl stop firewalld
systemctl disable firewalld
# 安装 k3s
curl -sfL http://rancher-mirror.cnrancher.com/k3s/k3s-install.sh | INSTALL_K3S_MIRROR=cn sh -s - --docker

使用 containerd 安装

`1`	`curl -sfL http://rancher-mirror.cnrancher.com/k3s/k3s-install.sh \| INSTALL_K3S_MIRROR=cn sh -`

安装完检查

安装完成后，可以执行以下命令进行主机检查。

# 运行配置检查
k3s check-config
# 查看节点状态以及 k3s 版本
[root@k3s-master ~]# kubectl get node
NAME             STATUS   ROLES                  AGE   VERSION
vm-16-8-centos   Ready    control-plane,master   52m   v1.21.5+k3s2
# 查看所有 pod 信息
[root@k3s-master ~]# kubectl get pods -A
NAMESPACE     NAME                                      READY   STATUS      RESTARTS   AGE
kube-system   local-path-provisioner-5ff76fc89d-bbps4   1/1     Running     0          52m
kube-system   coredns-7448499f4d-42v9x                  1/1     Running     0          52m
kube-system   metrics-server-86cbb8457f-xqlrg           1/1     Running     0          52m
kube-system   helm-install-traefik-crd-9wk9v            0/1     Completed   0          52m
kube-system   helm-install-traefik-d8llf                0/1     Completed   3          52m
kube-system   svclb-traefik-jqxvf                       2/2     Running     0          49m
kube-system   traefik-97b44b794-wv6zv                   1/1     Running     0          49m

截止到这里 k3s 已经安装完毕。

安装 nfs

安装 nfs 服务

1
2

yum -y install nfs-utils
systemctl start nfs && systemctl enable nfs

创建nfs目录

`1`	`mkdir -p /home/k8s/nfs`

修改权限

`1`	`chmod -R 755 /home/k8s/nfs`

编辑export文件

1
2
3

cat >>/etc/exports << EOF
/home/k8s/nfs *(rw,no_root_squash,sync)
EOF

配置生效

`1`	`exportfs -r`

启动rpcbind、nfs服务

1
2

systemctl restart rpcbind && systemctl enable rpcbind
systemctl restart nfs && systemctl enable nfs

到这里 k3s 以及 nfs 已经安装完成，下面就可以去体验了。
如果想以上都比较麻烦，你可以用下面的一键安装脚本来执行

一键安装 k3s 脚本

#!/bin/bash
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
LANG=en_US.UTF-8

RD="\033[31m"      # 错误消息
GR="\033[32m"      # 成功消息
YL="\033[33m"      # 告警消息
BL="\033[36m"      # 日志消息
PL='\033[0m'

clear
echo -e "${YL}##################################################${PL}"
echo -e "${YL}#${PL} ${GR}脚本名称${PL}: 一键安装 k3s 脚本                    ${YL}#${PL}"
echo -e "${YL}#${PL} ${GR}作    者${PL}: sre运维博客                          ${YL}#${PL}"
echo -e "${YL}#${PL} ${GR}网    址${PL}: https:www.cnsre.cn                   ${YL}#${PL}"
echo -e "${YL}#${PL} ${GR}文章地址${PL}: https://cnsre.cn/posts/211109907029/ ${YL}#${PL}"
echo -e "${YL}##################################################${PL}"
sleep 0.5

set -e
echo  
echo 
echo
echo -e "${RD}是否确定安装 dockerb版本的 k3s? ${PL}"
read -r -p "确定请按 y 任意键则退出！请选择：[y/n]" input
    if [[ $input != "y" ]]; then
        exit 1
    else 
        echo -e "$GR正在开始安装 dockerb版本的 k3s$PL"
    fi

if [ `command -v docker` ];then
    echo -e "${YL}docker 已经安装,正在添加docker加速源${PL}"
else
    echo -e "${GR}install docker${PL}"
    curl https://download.daocloud.io/docker/linux/centos/docker-ce.repo -o /etc/yum.repos.d/docker-ce.repo
    yum -y install https://download.daocloud.io/docker/linux/centos/7/x86_64/stable/Packages/containerd.io-1.2.6-3.3.el7.x86_64.rpm
    curl -fsSL https://get.daocloud.io/docker | bash -s docker --mirror Aliyun
fi

sudo mkdir -p /etc/docker
tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["http://f1361db2.m.daocloud.io"]
}
EOF
grubby --args="user_namespace.enable=1" --update-kernel="$(grubby --default-kernel)"

sudo systemctl daemon-reload
sudo systemctl restart docker
sudo systemctl enable docker


if [ `command -v k3s` ];then
    echo -e "${YL}k3s 已经安装${PL}"
	exit 1
else
    export K3S_NODE_NAME=${HOSTNAME//_/-}
    export INSTALL_K3S_EXEC="--docker --kube-apiserver-arg service-node-port-range=1-65000 --no-deploy traefik --write-kubeconfig ~/.kube/config --write-kubeconfig-mode 666"
    curl -sfL http://rancher-mirror.cnrancher.com/k3s/k3s-install.sh | INSTALL_K3S_MIRROR=cn sh -
fi

echo -e "${GR}export K3S_TOKEN=$(cat /var/lib/rancher/k3s/server/node-token)${PL}"
echo -e "${GR}export K3S_URL=https://$(ip addr | grep -E -o '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | grep -E -v "^127\.|^255\.|^0\." | head -n 1):6443${PL}"
echo -e "${GR}安装结束，请重启服务器${PL}"
read -r -p "确定请按 y 任意键则退出！请选择：[y/n]" input
    if [[ $input != "y" ]]; then
        reboot
    else 
        exit 1
    fi

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211109907029/
相关话题：https://www.cnsre.cn/tags/k3s/

kvm 安装 windows 虚拟机

Wenlong — Mon, 08 Nov 2021 08:48:06 +0800

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211108848062/
相关话题：https://www.cnsre.cn/tags/kvm/

安装前准备

验证CPU是否支持KVM

如果结果中有vmx（Intel）或svm(AMD)字样，就说明CPU的支持的。

`1`	`egrep '(vmx\|svm)' /proc/cpuinfo`

关闭SELinux

将 /etc/sysconfig/selinux 中的 SELinux=enforcing 修改为 SELinux=disabled

安装一些最基本的服务

可选项，因为我是刚安装好的CentOS，所以为了下面方便点，先把一些必要的工具安装下

`1`	`yum install epel-release net-tools vim unzip zip wget ftp -y`

安装KVM及其依赖项

`1`	`yum install qemu-kvm libvirt virt-install bridge-utils -y`

验证安装结果

下图说明已经成功安装了

`1`	`lsmod \| grep kvm`

开启kvm服务

并且设置其开机自动启动

`1`	`systemctl start libvirtd systemctl enable libvirtd`

查看状态操作结果

如下图所示，说明运行情况良好

`1`	`systemctl status libvirtd`

`1`	`systemctl is-enabled libvirtd`

配置网桥模式

先将 /etc/sysconfig/network-scripts/ 目录下的网卡配置文件备份一份

创建 ifcfg-br0 文件

创建的 br0文件的IP地址要和物理网卡的IP地址一致，命令 ipconfig 查看物理网卡将不会显示IP

内容如下：

[root@bogon ~]*# vim /etc/sysconfig/network-scripts/ifcfg-br0*

DEVICE=br0
BOOTPROTO=none
DEFROUTE=yes
ONBOOT=yes
TYPE=Bridge
IPV4_FAILURE_FATAL=yes
IPADDR=192.168.1.130
NETMASK=255.255.255.0
GATEWAY=192.168.1.254
DNS1=221.6.4.66
DELAY=0
USERCE=no

修改原网卡配置

vim /etc/sysconfig/network-scripts/ifcfg-eno1s
TYPE="Ethernet"
PROXY_METHOD="none"
BROWSER_ONLY="no"
BOOTPROTO="static"
DEFROUTE="yes"
IPV4_FAILURE_FATAL="YES"
IPV6INIT="yes"
IPV6_AUTOCONF="yes"
IPV6_DEFROUTE="yes"
IPV6_FAILURE_FATAL="no"
IPV6_ADDR_GEN_MODE="stable-privacy"
NAME="eno1"
UUID="bb40d726-8d67-4187-90c3-eb61e1b42d61"
DEVICE="eno1"
ONBOOT="yes"
IPADDR="192.168.1.130"
NETAMSK=255.255.255.0
GATEWAY="192.168.1.254"
DNS1="221.6.4.66"
IPV6_PRIVACY="no"
BRIDGE=br0

重启网络服务

`1`	`systemctl restart network`

使用 ifconfig 验证操作结果,多了一块网卡 br0 ，现在访问宿主机使用 192.168.1.130 就可以了。

安装虚拟机

准备操作系统安装镜像文件

在本文中将使用和宿主环境一样的 CentOS7.2，把该文件放到 /home/iso 目录下

挂载U盘

[root@nkgtsv01 ~]# fdisk -l
WARNING: fdisk GPT support is currently new, and therefore in an experimental phase. Use at your own discretion.

磁盘 /dev/sda：2995.0 GB, 2994995200000 字节，5849600000 个扇区
Units = 扇区 of 1 * 512 = 512 bytes
扇区大小(逻辑/物理)：512 字节 / 4096 字节
I/O 大小(最小/最佳)：4096 字节 / 4096 字节
磁盘标签类型：gpt
Disk identifier: 434CB2EB-C42E-4B9D-A76B-B759709EC159


#         Start          End    Size  Type            Name
 1         2048       206847    100M  EFI System      EFI System Partition
 2       206848       616447    200M  Microsoft basic
 3       616448   5849597951    2.7T  Linux LVM

磁盘 /dev/mapper/centos-root：214.7 GB, 214748364800 字节，419430400 个扇区
Units = 扇区 of 1 * 512 = 512 bytes
扇区大小(逻辑/物理)：512 字节 / 4096 字节
I/O 大小(最小/最佳)：4096 字节 / 4096 字节


磁盘 /dev/mapper/centos-swap：17.2 GB, 17179869184 字节，33554432 个扇区
Units = 扇区 of 1 * 512 = 512 bytes
扇区大小(逻辑/物理)：512 字节 / 4096 字节
I/O 大小(最小/最佳)：4096 字节 / 4096 字节


磁盘 /dev/mapper/centos-home：322.1 GB, 322122547200 字节，629145600 个扇区
Units = 扇区 of 1 * 512 = 512 bytes
扇区大小(逻辑/物理)：512 字节 / 4096 字节
I/O 大小(最小/最佳)：4096 字节 / 4096 字节


磁盘 /dev/mapper/centos-tmp：107.4 GB, 107374182400 字节，209715200 个扇区
Units = 扇区 of 1 * 512 = 512 bytes
扇区大小(逻辑/物理)：512 字节 / 4096 字节
I/O 大小(最小/最佳)：4096 字节 / 4096 字节


磁盘 /dev/mapper/centos-data：2333.2 GB, 2333249372160 字节，4557127680 个扇区
Units = 扇区 of 1 * 512 = 512 bytes
扇区大小(逻辑/物理)：512 字节 / 4096 字节
I/O 大小(最小/最佳)：4096 字节 / 4096 字节


磁盘 /dev/sdb：31.0 GB, 31004295168 字节，60555264 个扇区
Units = 扇区 of 1 * 512 = 512 bytes
扇区大小(逻辑/物理)：512 字节 / 512 字节
I/O 大小(最小/最佳)：512 字节 / 512 字节
磁盘标签类型：dos
磁盘标识符：0xcad4ebea            需要挂载的硬盘

   设备 Boot      Start         End      Blocks   Id  System
/dev/sdb4   *         256    60555263    30277504    7  HPFS/NTFS/exFAT
[root@nkgtsv01 ~]# mkdir -p /mnt/udisk
[root@nkgtsv01 ~]# ls
anaconda-ks.cfg
[root@nkgtsv01 ~]# ls /mnt/
udisk  usb
[root@nkgtsv01 ~]# mount -t ntfs-3g /dev/sdb4 /mnt/udisk/
mount: 未知的文件系统类型“ntfs-3g”

[root@nkgtsv01 ~]# yum list *ntfs*
已加载插件：fastestmirror
Loading mirror speeds from cached hostfile
 * base: ftp.sjtu.edu.cn
 * epel: mirrors.ustc.edu.cn
 * extras: ftp.sjtu.edu.cn
 * updates: ftp.sjtu.edu.cn
可安装的软件包
ntfs-3g.x86_64                              2:2017.3.23-1.el7                        epel
ntfs-3g-devel.x86_64                        2:2017.3.23-1.el7                        epel
ntfsprogs.x86_64                            2:2017.3.23-1.el7                        epel

已安装:
  ntfs-3g.x86_64 2:2017.3.23-1.el7

完毕！
[root@nkgtsv01 ~]#yum install ntfs-3g.x86_64 -y

[root@nkgtsv01 ~]# mount -t ntfs-3g /dev/sdb4 /mnt/udisk/
The disk contains an unclean file system (0, 0).
The file system wasn't safely closed on Windows. Fixing.

[root@nkgtsv01 ~]#
[root@nkgtsv01 ~]# ls /mnt/
udisk  usb
[root@nkgtsv01 ~]# ls /mnt/udisk/
CentOS-7.2-x86_64-DVD-1611.iso  CentOS-7-x86_64-DVD-1708.iso  maven_storey2.zip
[root@bogon data]# mkdir -p /data/iso
[root@bogon data]# ls
iso  kvm-bak  network
[root@nkgtsv01 ~]# mount  -o loop /mnt/udisk/CentOS-7-x86_64-DVD-1708.iso /data/iso/
mount: /dev/loop0 写保护，将以只读方式挂载

创建虚拟机文件存放的目录

`1`	`mkdir -p /data/kvm-images`

⚠️ 注意

关于virtio-win驱动

virtio-win驱动主要用于kvm里的 windows虚拟机。virtio-win提供yum源安装rpm包，virtio驱动默认会安装在/usr/share/virtio-win目录中，可共享于kvm里的windows虚拟机。

sudo wget https://fedorapeople.org/groups/virt/virtio-win/virtio-win.repo -O /etc/yum.repos.d/virtio-win.repo
# 添加repo

该repo文件提供两个不同的仓库：

virtio-win-stable
默认，该仓库的版本和RHEL版本关联在一起发布，意味着得到了非常多的测试，很稳定。
virtio-win-latest
该仓库提供最新的build版本，这些版本可能有各种问题，用户需自己承担风险。这个仓库默认是disable的。如果你想从稳定版更新到最新版，可以使用如下命令：
1

sudo yum --enablerepo=virtio-win-latest update virtio-win

安装完成后的文件会存放在/user/share，内容如下：

/usr/share/virtio-win/*.iso: ISO镜像，包含所有驱动，详细内容后面会描述
/usr/share/virtio-win/*.vfd: 用于Windows XP下的VFD软驱镜像
/usr/share/virtio-win/drivers: 从VFD软驱镜像中提取的文件
/usr/share/guest-agent/*.msi: QEMU Guest Agent 32bit 和 64bit 安装包

其中ISO镜像内容为:

NetKVM/: Virtio网络驱动
viostor/: Virtio块驱动
vioscsi/: Virtio SCSI驱动
viorng/: Virtio RNG驱动
vioser/: Virtio串口驱动
Balloon/: Virtio 内存气球驱动
qxl/: 用于Windows 7及之前版本的QXL显卡驱动. (virtio-win-0.1.103-1和之后版本会创建)
qxldod/: 用于Windows 8及之后版本的QXL显卡驱动. (virtio-win-0.1.103-2和之后版本会创建)
pvpanic/: QEMU pvpanic 设备驱动 (virtio-win-0.1.103-2和之后版本会创建)
guest-agent/: QEMU Guest Agent 32bit 和 64bit 安装包
qemupciserial/: QEMU PCI 串口设备驱动

或者你也可以通过一下方获取

稳定版virtio-win iso

稳定版virtio-win x86 floppy

稳定版virtio-win amd64 floppy

最新版virtio-win iso

最新版virtio-win x86 floppy

最新版virtio-win amd64 floppy

最新版qemu-ga files

全部下载目录

变更日志

使用 virt-install 创建虚拟机

[root@bogon data]# virt-install --virt-type kvm --name=njvm2k8 --ram=1024 --vcpus=1 --os-type=windows --accelerate --cdrom=/home/kvm_data/iso/cn_windows_server_2008_r2_617396.iso --disk path=/usr/share/virtio-win/virtio-win.iso,device=cdrom --disk path=/home/kvm_data/img/njvm2k8.qcow2,bus=virtio --network bridge=br0 --graphics vnc,listen=0.0.0.0,password=123456,port=5920 --noautoconsole
 

WARNING  无法连接到图形控制台：没有安装 virt-viewer。请安装 'virt-viewer' 软件包。
WARNING  没有控制台用于启动客户机，默认为 --wait -1
开始安装......
正在分配 'njvm2k8.img'                                   | 200 GB  00:00:00
正在删除磁盘 'njvm2k8.img'                                |    0 B  00:00:00
域安装失败，您可以运行下列命令重启您的域：
'virsh start virsh --connect qemu:///system start njvm2k8'
否则请重新开始安装

不要理会里面提示的错误，接着往下走

命令含义

virt-install 
--name=客户机名称  
--ram 内存（1024）1G 
--vcpus= cpu1 
--os-type= 客户机系统类型  
--os-variant= win2k8 
--disk path= 客户机文件存放路径 ,
size=客户机硬盘大小200 
--accelerate 
--cdrom  （镜像文件路径） 
--vnc --vncport=vnc远程端口 5910 
--network bridge=网卡桥接 br0,model=virtio 
--noautoconsole

打开防火墙上的5910端口

因为 VNC 使用的端口默认是 5910 所以需要打开防火墙，防火墙若关闭请忽略

`1`	`firewall-cmd --zone=public --add-port=5910/tcp --permanent`

查看打开新创建的虚拟机

1
2

virsh list --all
virsh start njvm2k8-win

使用VNC链接虚拟机

vncviewer下载地址

使用VNC输入宿主机IP地址加上端口号输入虚拟机名字然后打开

⚠️ 注意

安装的时候找不到硬盘

如果再安装的时候找不到硬盘，请执行一下操作

挂载win镜像

`1`	`virsh change-media njvm2k8 hdb /usr/share/virtio-win/virtio-win.iso`

然后取消挂载的镜像把系统镜像从新挂载到系统进行分区安装系统

安装完毕重启虚拟机

安装完会重启windows虚拟机

我们查看状态然后启动虚拟机

等待安装完成

启动之后设置密码我们就进入了新的windows 操作系统

用vnc链接

⚠️ 注意
挂载软驱（硬盘驱动网卡驱动等）注释：网卡驱动要在系统中装好之后挂载不然装系统的时候会提示找不到光盘镜像

在宿主机中执行命令

`1`	`virsh change-media njvm2k8 hdb /usr/share/virtio-win/virtio-win.iso`

VMTools工具安装完成后,使用如下命令卸载掉挂载的VMTools工具:

a.如果是Linux虚拟机,执行如下命令卸载VMTools工具:

virsh change-media 【虚拟机ID】 --eject 【vmtools-linux.iso文件全路径】

b.如果是Windows虚拟机,执行如下命令卸载VMTools工具:

virsh change-media 【虚拟机ID】 --eject 【vmtools-windows.iso文件全路径】

挂载驱镜像文件到njvm2k8主机上

用vnc链接

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211108848062/
相关话题：https://www.cnsre.cn/tags/kvm/

Centos7搭建 KVM 命令行安装虚拟机

Wenlong — Fri, 05 Nov 2021 08:52:09 +0800

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211105852095/
相关话题：https://www.cnsre.cn/tags/kvm/

本文将介绍centos7 环境如何搭建一个kvm 环境并且创建windows，linux等虚拟机。

安装前准备

验证CPU是否支持KVM

如果结果中有vmx（Intel）或svm(AMD)字样，就说明CPU的支持的。

`1`	`egrep '(vmx\|svm)' /proc/cpuinfo`

关闭SELinux

将 /etc/sysconfig/selinux 中的 SELinux=enforcing 修改为 SELinux=disabled

安装一些最基本的服务

可选项，因为我是刚安装好的CentOS，所以为了下面方便点，先把一些必要的工具安装下

`1`	`yum install epel-release net-tools vim unzip zip wget ftp -y`

安装KVM及其依赖项

`1`	`yum install qemu-kvm libvirt virt-install bridge-utils -y`

验证安装结果

下图说明已经成功安装了

`1`	`lsmod \| grep kvm`

开启kvm服务

并且设置其开机自动启动

`1`	`systemctl start libvirtd systemctl enable libvirtd`

查看状态操作结果

如下图所示，说明运行情况良好

`1`	`systemctl status libvirtd`

`1`	`systemctl is-enabled libvirtd`

配置网桥模式

先将 /etc/sysconfig/network-scripts/ 目录下的网卡配置文件备份一份

创建 ifcfg-br0 文件

创建的 br0文件的IP地址要和物理网卡的IP地址一致，命令 ipconfig 查看物理网卡将不会显示IP

内容如下：

[root@bogon ~]# vim /etc/sysconfig/network-scripts/ifcfg-br0
DEVICE=br0
BOOTPROTO=none
DEFROUTE=yes
ONBOOT=yes
TYPE=Bridge
IPV4_FAILURE_FATAL=yes
IPADDR=192.168.1.130
NETMASK=255.255.255.0
GATEWAY=192.168.1.254
DNS1=221.6.4.66
DELAY=0
USERCE=no

修改原网卡配置

vim /etc/sysconfig/network-scripts/ifcfg-eno1s
TYPE="Ethernet"
PROXY_METHOD="none"
BROWSER_ONLY="no"
BOOTPROTO="static"
DEFROUTE="yes"
IPV4_FAILURE_FATAL="YES"
IPV6INIT="yes"
IPV6_AUTOCONF="yes"
IPV6_DEFROUTE="yes"
IPV6_FAILURE_FATAL="no"
IPV6_ADDR_GEN_MODE="stable-privacy"
NAME="eno1"
UUID="bb40d726-8d67-4187-90c3-eb61e1b42d61"
DEVICE="eno1"
ONBOOT="yes"
IPADDR="192.168.1.130"
NETAMSK=255.255.255.0
GATEWAY="192.168.1.254"
DNS1="221.6.4.66"
IPV6_PRIVACY="no"
BRIDGE=br0

重启网络服务

`1`	`systemctl restart network`

使用 ifconfig 验证操作结果,多了一块网卡 br0 ，现在访问宿主机使用 192.168.1.130 就可以了。

安装虚拟机

准备操作系统安装镜像文件

在本文中将使用和宿主环境一样的 CentOS7.2，把该文件放到 /home/iso 目录下

挂载U盘

[root@nkgtsv01 ~]# yum install fuse-ntfs-3g -y
[root@nkgtsv01 ~]# ls /mnt/
udisk  usb
[root@nkgtsv01 ~]# ls /mnt/udisk/
CentOS-7.2-x86_64-DVD-1611.iso  CentOS-7-x86_64-DVD-1708.iso  maven_storey2.zip
[root@bogon data]# mkdir -p /data/iso
[root@bogon data]# ls
iso  kvm-bak  network
[root@nkgtsv01 ~]# mount  -o loop /mnt/udisk/CentOS-7-x86_64-DVD-1708.iso /data/iso/
mount: /dev/loop0 写保护，将以只读方式挂载

创建虚拟机文件存放的目录

`1`	`mkdir -p /data/kvm-images`

使用 virt-install 创建虚拟机

virt-install --virt-type=kvm --name=njkvm07 --vcpus=4 --memory=6000 --location=/data/iso/CentOS-7-x86-64-DVD-1708.iso --disk path=/data/kvm-images/njkvm07.qcow2,size=200,format=qcow2 --network bridge=br0 --graphics none --extra-args='console=ttyS0' --force

执行完这段命令

感叹号为待选项

c保存 q退出 b开始执行安装

选择地区时间

选则之后c保存

自动返回主页面

选择硬盘

选择到硬盘 c保存

全新安装 C保存

选则添加IP地址和添加主机名称

输入回车

添加IP地址

选则ipv4

添加IP地址回车

添加netmask gateway c 保存

添加密码

B开始执行安装

安装完成

宿主机直接连接到虚拟机

等待重启虚拟机，虚拟机起开之后直接远程就ok了。

virt-clone克隆虚拟机

使用 virt-clone 克隆新的虚拟机

（虚拟机需要先关闭）

`1`	`virt-clone -o njvm02 -n njvm03 -f /data/kvm-img/njvm03.img`

克隆完查看所有的虚拟机以及状态

`1`	`virsh list --all`

删除虚拟机 njvm01

1
2

virsh undefine njvm01 
virsh destroy njvm01

⚠️ 注意

取消定义删除以后要找到虚拟机文件路径吧虚拟机文件也删除掉

[root@nkgtsv01 data]# virsh shutdown njvm01
域 njvm01 被关闭
[root@nkgtsv01 data]# virsh start njvm02
域 njvm02 已开始
[root@nkgtsv01 data]# virsh list --all

⚠️ 注意

克隆完以后因为IP地址还是njvm01的IP地址所以我们要修改IP地址

开启我们克隆的虚拟机

远程登陆上去

[root@nkgtsv-vm01 ~]# cd /etc/sysconfig/network-scripts/
[root@nkgtsv-vm01 network-scripts]# ls
ifcfg-eth0   ifdown-ppp       ifup-eth     ifup-sit
ifcfg-lo     ifdown-routes    ifup-ippp    ifup-Team
ifdown       ifdown-sit       ifup-ipv6    ifup-TeamPort
ifdown-bnep  ifdown-Team      ifup-isdn    ifup-tunnel
ifdown-eth   ifdown-TeamPort  ifup-plip    ifup-wireless
ifdown-ippp  ifdown-tunnel    ifup-plusb   init.ipv6-global
ifdown-ipv6  ifup             ifup-post    network-functions
ifdown-isdn  ifup-aliases     ifup-ppp     network-functions-ipv6
ifdown-post  ifup-bnep        ifup-routes
[root@nkgtsv-vm01 network-scripts]# vim ifcfg-eth0

IPADDR=192.168.1.121 改为我们想要的IP地址

保存退出

Service network restart

重启网络

重新链接

参考文档：
http://www.linuxidc.com/Linux/2017-01/140007.htm
http://blog.csdn.net/u011414200/article/details/47310827
https://www.cnblogs.com/5201351/p/4445199.html
http://blog.51cto.com/7834466/2064277
https://www.cnblogs.com/Yemilice/p/8080688.html

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211105852095/
相关话题：https://www.cnsre.cn/tags/kvm/

zabbix 监控 aws rds 数据库

Wenlong — Wed, 03 Nov 2021 10:06:34 +0800

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211103006342/
相关话题：https://www.cnsre.cn/tags/zabbix/

环境准备

zabbix-agent 

python2.7 

pip 

安装python 模块 

pip2.7 install boto3  

pip install awscli

部署py脚本

git地址：https://github.com/datorama/zabbix_rds_template

# 克隆模板
git clone https://github.com/datorama/zabbix_rds_template.git
# 进入模板目录
cd zabbix_rds_template
# 可以看到一下内容 zabbix用的py为脚本 xml 为zabbix web端的模板
rds_stats.py  rds_template.xml  README.md
# 把zabbix需要用的脚本放在zabbix 执行脚本的目录
cp  rds_stats.py usr/local/share/zabbix/externalscripts 
cd usr/local/share/zabbix/externalscripts 
chmod +x rds_stats.py 
# 给执行权限

准备密钥ID 和访问密钥

Access key ID	Secret access key
AKxxxxxxxxxxxxxxxxx	SKxxxxxxxxxxxxxxxxx

# 执行命令 
aws configure  
# 配置访问秘钥、私有访问秘钥、可用区域等，最后的格式为json格式

添加主机模板

先导入模板rds_template.xml

添加主机填入主机名称 dns 名称为RDS的 Endpoint

添加模板

在模板的宏部分{$ AWS_ACCESS_KEY} ，{$ AWS_SECRET_KEY}中输入aws的aksk或将其留空以使用IAM角色

在模板的宏部分{$ REGION}中设置默认的AWS区域

{$ AWS_ACCESS_KEY} = AKxxxxxxxxxxxxxxxxx
{$ AWS_SECRET_KEY} = SKxxxxxxxxxxxxxxxxx
{$ REGION} = cn-north-1

点击添加等待数据

⚠️ 注意
需要注意的点是要安装py的一些模块。

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211103006342/
相关话题：https://www.cnsre.cn/tags/zabbix/

zabbix 使用 web 监控功能监控 url

Wenlong — Mon, 01 Nov 2021 09:50:00 +0800

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211101950005/
相关话题：https://www.cnsre.cn/tags/zabbix/

前言介绍

需要对页面 url 对页面的延迟，访问时间进行监控。如果页面不是正常的状态就发送告警。基于这个需求，使用zabbix 对url 的进行监控，使用的是zabbix 的web监控功能。

选择主机添加应用集

选在相应主机，并添加Web监控

按照方式新建Web场景

注意：

　　名称统一规则：相应的域名

　　应用集：选择之前创建的或者新建一个，名称为URL 告警

　　更新间隔：默认为1m

　　尝试次数：默认1次

　　客户端：选择IE 11.0

添加

添加步骤

⚠️注意：

　　名称使用和场景名称一样即可：域名地址

　　URL：复制nagios的URL地址，将域名替换为zabbix上的宏:端口{HOST.IP}:80

　　　　如：http://http://download.tujia.com/monitor.html

　　　　写为：http://http://{HOST.IP}/monitor.html

　　　　PS：如果地址为 https 访问，此处直接写http即可

　　头部：

　　　　名称：host

　　　　值：填写为监控页面的域名，如此例中的 download.tujia.com

　　　要求的字符串：填写之前访问测试页面包含的字符串，如ok、IsSuccess:true等，此例为{"status":"failure","message":"-1 参数不全"}

URL地址

添加完成，并且检测成功后，可观察如下

主机中没有报错信息

添加告警，触发报警

1）切回原主机界面，添加触发器

2）创建触发器：

⚠️注意：

　　触发器名称：规则为域名+无法响应，如此例中的download.tujia.com+无法响应

　　严重性：选择一般严重

　　表达式：建立过程如下

　　　　如下图中，当建立完web检测后，主机中会生成响应的监控项，其中一项web.test.fail[web_check_download.tujia.com],

　　　　若web检测失败，此监控项的值为1，若正常，则为0

　　　　用于检测此web检测是否成功，此例中的trigger含义为，当此web检测连续3min检测失败（选择周期T的最小值>N，T为3m），则触发，表达式的构建如下：

　　　　{主机名称:监控项名称.条件}+比较符号+数值，如下为此例中的表达式

　　　　{HZ 3A 150:web.test.fail[URLapi.php告警].min(3m)}<0

　　　　{ 主机名 :监控项（此web检测失败） .条件（三分钟内）}>0

表达式：如果最近连续4次取到的response_code 值不是200（网站响应代码），则触发报警

{192.168.3.86:web.test.rspcode[3.86_http_status,3.86_http_status].last(0)}<>200 and {192.168.3.86:web.test.rspcode[3.86_http_status,3.86_http_status].last(1)}<>200 and {192.168.3.86:web.test.rspcode[3.86_http_status,3.86_http_status].last(2)}<>200 and {192.168.3.86:web.test.rspcode[3.86_http_status,3.86_http_status].last(3)}<>200

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211101950005/
相关话题：https://www.cnsre.cn/tags/zabbix/

删除文件后 df 查看磁盘空间并没有释放

Wenlong — Fri, 29 Oct 2021 09:55:13 +0800

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211029955133/
相关话题：https://www.cnsre.cn/tags/故障集/

前言

Linux 磁盘空间总是报警，查到到大文件，删除之后，df看到磁盘空间并没有释放。

用 du -sh ./* | sort -nr （查看当前目录下文件的大小）通过查找了下发现文件被mysql 的zabbix库占用了 zabbix 已经迁移可以删除

rm 删除之后 df 查看发现磁盘空间并没有得到释放

执行 lsof | grep deleted 发现有大量刚刚删除文件的进程存在

kill掉进程（或者重启进程） OK

问题分析

一般说来不会出现删除文件后空间不释放的情况，但是也存在例外，比如文件被进程锁定，或者有进程一直在向这个文件写数据等等，要理解这个问题，就需要知道Linux下文件的存储机制和存储结构。

一个文件在文件系统中的存放分为两个部分：数据部分和指针部分，指针位于文件系统的 meta-data 中，数据被删除后，这个指针就从 meta-data 中清除了，而数据部分存储在磁盘中，数据对应的指针从 meta-data 中清除后，文件数据部分占用的空间就可以被覆盖并写入新的内容，之所以出现删除 access_log 文件后，空间还没释放，就是因为 httpd 进程还在一直向这个文件写入内容，导致虽然删除了 access_log 文件，但文件对应的指针部分由于进程锁定，并未从 meta-data 中清除，而由于指针并未被删除，那么系统内核就认为文件并未被删除，因此通过 df 命令查询空间并未释放也就不足为奇了。

处理问题

既然有了解决问题的思路，那么接下来看看是否有进程一直在向文件中写，这里需要用到 Linux 下的 lsof 命令，通过这个命令可以获取一个已经被删除但仍然被应用程序占用的文件列表，命令执行如下图所示：

作者：SRE运维博客
博客地址： https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/211029955133/
相关话题：https://www.cnsre.cn/tags/故障集/

大于2T硬盘安装 Redhat 系统

Wenlong — Wed, 27 Oct 2021 09:57:50 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/211027957506/
相关话题：https://www.cnsre.cn/tags/故障集/

最近接到一个case 涉及到Linux下面大硬盘(大于2T)的使用,以后大家遇到大硬盘的可能性会越来越多,特把处理过程分享出来,以供大家参考

问题背景

Dell r85 机架式服务器配置6个1T硬盘, 做完底层raid后,操作系统可以认到3T

问题

在实际使用中,系统只用到2T的空间,最后1T始终无法分区,报错如下:

原因分析

安装Linux时,使用了普通的MBR模式 ,对主流主板BIOS而言，MBR分区定义每个扇区512字节，磁盘寻址32位地址，所能访问的磁盘容量最大是2.19TB（512 * 232）,因此系统能使用的最大空间也为2T

解决方案

通过咨询Dell 原厂,提供了两个解决方案

1.安装Linux 系统时重新更改 BIOS的启动模式为UEFI

2.重新划分底层 raid 划分为一个小于 2T 的盘做为安装系统的盘,另一个大于2T的盘做为数据盘使用.

实操过程

在遇到大硬盘后,最好电询原厂,看是否支持UEFI

另外: 在划分区时,如果选择自定义,在redhat 6.X 之后要必须要新建 /boot/efi 分区.大小不能小于 100M 我在实际操作时设置了200M

原厂的解释是:

/boot/efi/ partition (100 MB minimum) — the partition mounted on /boot/efi/ contains all the installed kernels, the initrd images, and ELILO configuration files.

修改BIOS中设置,下面以Dell R815 为例说明修改

1.重启主机,按F2 进入BIOS 设置 (或按各厂商提示),

出现该界面后,按 F2 ,

生效后如下图

在引导到一定阶段后会自动进入BIOS 设置,按方向键上,下选择 [Boot Settings] 后,回车

在小窗口用方向键选择 [Boot Mode] 使用 -/+ 选择启动方式为 [UEFI]

修改后ESC退出时保存

note: uEFI does not read from legacy mbr labels

2.更改磁盘的 disk lable 更改为 GPT

因为On hardware where uEFI is enabled, the boot disk must have a GPT partition label

在安装任意介面,输入 Ctrl+Alt+F2 切换到命令行介面,使用 parted 更改 disk lable为 gpt

note: 如果是已经安装过系统的主机,这一步时必须要先将旧分区全部删除,才能更改成功

因为是重装,所以要先把旧分区删除,红框标示出来的就是传统的 mbr 模式,只能支持最大2T 的硬盘

删除旧分区

更改 disk label 为 gpt

更改完成后,使用 Ctrl+Alt+F6 回切至安装界面,按正常步骤安装即可

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/211027957506/
相关话题：https://www.cnsre.cn/tags/故障集/

zabbix 通过 agent 监控进程、端口

Wenlong — Mon, 25 Oct 2021 09:12:05 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/211025912047/
相关话题：https://www.cnsre.cn/tags/zabbix/

环境介绍

操作系统：centos 7.4

zabbix版本：zabbix server 3.4.7

客户端：zabbix-agent 3.4.7

监控进程：mysqld

监控端口：3306 tcp

进程监控

确认客户端已经安装且运行agent

查看进程

查看属于那个用户的几个进程

mysql 的进程为root用户两个进程

添加监控项

名称随便写

类型zabbix客户端

键值选则进程数返回数

应用集选则prosesses 进程

proc.num[<name>,<user>,<state>,<cmdline>]

以下是对mysql进程的监控配置，key中的参数说明，

<name>第一个参数是进程名字，没必要填写，填了反而会使监控不太准确（仅个人测试）

<user>第二个参数是运行进程的用户名

<state>第三个为进程的状态，一般选则all 包括：all (default), run, sleep, zomb

<cmdline>第四个参数用来指定进程名中包含的字符，对进程进行过滤。

确认更新

创建触发器

选择刚才创建的监控项

插入

修改{hgh3a01:proc.num[,root,all,mysqld].last()}=0

为

{hgh3a01:proc.num[,root,all,mysqld].max(#2)}=2

hgh3a01：主机名称

proc.num[,root,all,mysqld]：监控项

max(#2)}=2 ：表示最后两次的接收到的值都是2个进程（ps -ef 看到 mysqld 的进程为两个所以=2 ），说明mysqld进程在运行，则出发报警。

因为我们要测试是否能出发告警，所以要选则 =2 正常的<1 就是没有运行。

稍等几分钟观察看看能不能触发触发器

收到邮箱警告

吧测试的进程改为正常的（因为mysql 运行的进程为两个我这变设置的触发器为进程小于两个进程就发出告警）

保存更新观察是否回复正常

监控端口

添加监控项

修改端口保存更新

同监控进程一样（先测试）

收到触发警告

吧之前的值调整为0

测试回复正常

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/211025912047/
相关话题：https://www.cnsre.cn/tags/zabbix/

zabbix自定义监控磁盘分区

Wenlong — Thu, 21 Oct 2021 09:50:31 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/211021950307/
相关话题：https://www.cnsre.cn/tags/zabbix/

系统环境

Zabbix 版本：3.4

操作系统版本：centos7.4

监控分区 / 、/boot 、/home

先创建监控项的模板

点击创建监控项

名称随意填写，键值的话因为我们监控车的是磁盘剩余的百分比所有选则次键值，应用集则选则filsystems

选则键值

选则添加我们的监控项已经创建。

查看监控项看下创建测监控项是否异常。

选则需要监控的主机

接下来我们来创建监控项。

监控项名称随意填写。

然后吧严重性选则为一般告警（因为我们短信邮箱告警等级是一般告警以上的告警等级推送）

选则我们刚才创建的监控项

修改表达式

写出监控的分区我们这以home分区为例。

完成以后添加即可。

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/211021950307/
相关话题：https://www.cnsre.cn/tags/zabbix/

Amazon EC2 永久修改静态 DNS

Wenlong — Tue, 12 Oct 2021 10:54:18 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/211012054181/
相关话题：https://www.cnsre.cn/tags/aws/

文章链接
在 /etc/resolv.conf 中配置了 DNS 只能临时生效，重启就丢失了，这种情况下如何永久修改保留 NDS 呢？

简短描述

默认情况下，与 Amazon Virtual Private Cloud (Amazon VPC) 关联的 Amazon EC2 实例在启动时使用动态主机配置协议 (DHCP) 请求 DNS 服务器地址。DHCP 响应返回写入到本地 /etc/resolv.conf 文件的 DNS 服务器地址。重新启动实例时，对具有自定义 DNS 服务器地址的 resolv.conf 文件的手动修改将丢失。您用于解决此问题的方法取决于您的 Linux 发行版。有关 VPC 和 DNS 服务器的更多信息，请参阅 Amazon DNS 服务器。

解决方法

⚠️ 重要提示：
更改 Amazon EC2 实例之前，使用 Amazon 系统映像 (AMI) 或 Amazon Elastic Block Store (Amazon EBS) 快照创建备份。更改实例的联网配置可能会导致实例无法访问。

Amazon Linux、Amazon Linux 2

使用以下选项之一来配置 Amazon EC2 实例。如果您同时应用这两个选项，则在 ifcfg-eth0 文件中指定的 DNS 服务器会优先（选项 2）。

要使任一选项正常运行，必须将 ifcfg-eth0 文件中的 PEERDNS 参数值设置为 yes。将 PEERDNS 参数设置为 no 意味着，ifcfg-* 文件中指定的或 DHCP 提供的 DNS 服务器会被忽略。

选项 1：

编辑或创建 /etc/dhcp/dhclient.conf 文件。

⚠️ 注意： 您必须拥有根用户权限才能编辑此文件。您可以使用 sudo -i 成为根用户，或者使用 sudo 执行所有命令。

2. 将 **supersede** 命令添加到文件以覆盖 domain-name-servers。在以下示例中，将 **xxx.xxx.xxx.xxx** 替换为您希望实例使用的 DNS 服务器的 IP 地址：

`1`	`supersede domain-name-servers xxx.xxx.xxx.xxx, xxx.xxx.xxx.xxx;`

在上述修改之后，resolv.conf 文件将在实例重启时更新，以仅包含您在 dhclient 文件中指定的 DNS 服务器。有关 supersede 命令的更多信息，请参阅 Linux 手册页上的 dhclient.conf(5)。

在每个接口的配置文件 (/etc/sysconfig/network-scripts/ifcfg-*) 中将 PEERDNS 参数设置为 yes。
重启 EC2 实例。

选项 2：

要覆盖 /etc/dhcp/dhclient.conf 文件中的 DNS 服务器值，请在每个接口的配置文件 (/etc/sysconfig/network-scripts/ifcfg-*) 中指定自定义 DNS 服务器。

例如，下例中显示来自 Amazon Linux 实例的 /etc/sysconfig/network-scripts/ifcfg-eth0 文件修改为包含两个自定义 DNS 服务器（DNS1 和 DNS2）：

DEVICE=eth0
BOOTPROTO=dhcp
ONBOOT=yes
TYPE=Ethernet
USERCTL=yes
PEERDNS=yes
IPV6INIT=no
PERSISTENT_DHCLIENT=yes
RES_OPTIONS="timeout:2 attempts:5"
DHCP_ARP_CHECK=no
MTU="9001"
DNS1=8.8.8.8
DNS2=8.8.4.4

在每个接口的配置文件 (/etc/sysconfig/network-scripts/ifcfg-*) 中将 PEERDNS 参数设置为 yes。

Ubuntu 16.04

编辑或创建 /etc/dhcp/dhclient.conf 文件。

⚠️ 注意： 您必须拥有根用户权限才能编辑此文件。您可以使用 sudo -i 成为根用户，或者使用 sudo 执行所有命令。

2. 将 supersede 命令添加到文件以覆盖 domain-name-servers。在以下示例中，将 xxx.xxx.xxx.xxx 替换为您希望实例使用的 DNS 服务器的 IP 地址：

supersede domain-name-servers xxx.xxx.xxx.xxx, xxx.xxx.xxx.xxx;

在此修改之后，resolv.conf 文件将在实例重启时更新，以仅包含您在 dhclient 文件中指定的 DNS 服务器。有关 supersede 命令的更多信息，请参阅 Linux 手册页上的 dhclient.conf(5)。

重启实例。

Ubuntu 18.04

默认情况下，在 Ubuntu 18.04 上，由 netplan.io 软件包处理网络接口配置，且由启用系统解析的服务使用存根解析程序处理 DNS 查询。存根解析程序 IP 位于 /etc/resolv.conf。

反过来，/etc/resolv.conf 文件是 /run/systemd/resolve/stub-resolv.conf 文件的符号链接。如果以下任一项对于 /etc/resolv.conf 文件为真，/etc/dhcp/dhclient.conf 中的 supersede 语句可能无法按预期起作用：

文件不是您的实例上的符号链接。
文件是一个指向不同文件的符号链接，如 /run/systemd/resolve/resolv.conf。

上述任一条件都表示自定义了默认的 Ubuntu 18.04 配置。

运行以下步骤以覆盖 DNS 服务器值：

Netplan 通常将配置文件存储在 /etc/netplan 目录中。创建名为 /etc/netplan/99-custom-dns.yaml 的文件，然后通过以下行填充此文件。请务必将占位符 DNS 服务器 IP 地址替换为首选地址：

network:
    version: 2
    ethernets:
        eth0:         
            nameservers:
                    addresses: [1.2.3.4, 5.6.7.8]
            dhcp4-overrides:
                    use-dns: false

在进行这些更改后，您将仍然可以在 /etc/resolv.conf 中看到存根解析程序 IP。这是正常的。存根解析程序 IP 对于您的操作系统来说是本地的，在后台中，存根解析程序将使用您在前述 99-custom-dns.yaml 文件中指定的 DNS 服务器。

重启实例。
运行 systemd-resolve 命令以确认系统正确地提取预期的 DNS 服务器 IP 地址：

`1`	`systemd-resolve --status`

RHEL 7.5

默认情况下，由 NetworkManager 服务管理 resolv.conf 文件。然后，该服务会通过 DHCP 提供的 DNS 服务器填充此文件。阻止 NetworkManager 管理 resolv.conf 文件，以使 resolv.conf 文件忽略 DHCP 提供的 DNS 服务器。

选项 1：

编辑或创建 /etc/dhcp/dhclient.conf 文件。

⚠️ 注意： 您必须拥有根用户权限才能编辑此文件。您可以使用 sudo -i 成为根用户，或者使用 sudo 执行所有命令。

2. 将 **supersede** 命令添加到文件以覆盖 domain-name-servers。在以下示例中，将 **xxx.xxx.xxx.xxx** 替换为您希望实例使用的 DNS 服务器的 IP 地址：

`1`	`supersede domain-name-servers xxx.xxx.xxx.xxx, xxx.xxx.xxx.xxx;`

在每个接口的配置文件 (/etc/sysconfig/network-scripts/ifcfg-*) 中将 PEERDNS 参数设置为 yes。
重启实例。

选项 2：

使用以下内容创建 /etc/NetworkManager/conf.d/disable-resolve.conf-managing.conf 文件：

[main]
dns=none

重启实例，然后手动填充 /etc/resolv.conf 文件。

相关视频

Pooja 演示了如何将重启期间保留的自定义 DNS 服务器分配给 Amazon EC2 实例

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/211012054181/
相关话题：https://www.cnsre.cn/tags/aws/

zabbix 监控 oracle 数据库

Wenlong — Sat, 09 Oct 2021 11:15:57 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/211009115571/
相关话题：https://www.cnsre.cn/tags/zabbix/

简介

Orabbix 是设计用来为 zabbix 监控 Oracle 数据库的插件，它提供多层次的监控，包括可用性和服务器性能指标。

它提供了从众多 oracle 实例采集数据的有效机制，进而提供此信息的监控和性能指标。然后，您可以利用的 zabbix 的报告功能为收集的所有数据，并提供分析。目前的发行版中包含了一组预先定义的模板，包括从初始部署警报和图形功能。然而，这些可以进行微调，以满足您的需求和数据/监控要求

环境介绍

系统环境：

linux Centos 7.4

3.10.0-693.21.1.el7.x86_64

zabbix版本

zabbix 3.4.7

Orabbix 监控什么？

数据库版本

归档日志与生产趋势分析

触发器，表/过程等命中率

逻辑 I/O 性能

物理 I/O 性能

PGA

SGA

共享池

Sessions

数据库大小

表空间

安装配置

zabbix server 端操作

Orabbix插件的下载

http://www.smartmarmot.com/product/orabbix/download/

安装 orabbix

创建目录

1
2
3

mkdir  -p /opt/orabbix
mv orabbix-1.2.3.zip /opt/orabbix
cd  /opt/orabbix

yum安装unzip

1
2
3

yum install unzip -y
# 解压oeabbix
unzip orabbix-1.2.3.zip

创建orabbix备份

cp conf/config.props.sample conf/config.props

启动程序拷贝至/etx/init.d/

cp init.d/orabbix  /etc/init.d/

分配权限

chmod  +x /etc/init.d/orabbix
chmod  +x /opt/orabbix/run.sh

安装jdk

yum install java -y

创建数据库账号

## oracle 服务器端操作 ##

登录 oracle 命令行

su - oracle       # 切换到 oracle 用户

sqlplus /nolog    # 不连接任何数据库

conn /as sysdba   # 用sysdba 登陆

# 或者

conn 用户名/密码

select instance_name from v$instance;  # 查看实例

首先我们需要在被监控的Oracle上面创建一个账号，用于zabbix的数据获取，在oracle的sqlplus里面执行

CREATE USER ZABBIX

IDENTIFIED BY "zabbix"

DEFAULT TABLESPACE SYSTEM

TEMPORARY TABLESPACE TEMP

PROFILE DEFAULT

ACCOUNT UNLOCK；

赋予角色权限

GRANT CONNECT TO ZABBIX;

GRANT RESOURCE TO ZABBIX;

ALTER USER ZABBIX DEFAULT ROLE ALL;

赋予系统权限

GRANT SELECT ANY TABLE TO ZABBIX;

GRANT CREATE SESSION TO ZABBIX;

GRANT SELECT ANY DICTIONARY TO ZABBIX;

GRANT UNLIMITED TABLESPACE TO ZABBIX;

GRANT SELECT ANY DICTIONARY TO ZABBIX;

如果我们的数据库是Oracle 11g，我们还需要执行下面的语句

注释：官方文档是需要执行这个语句的，测试没有执行也一样可以用，目前没有发现问题（可参考）

exec dbms_network_acl_admin.create_acl(acl => 'resolve.xml',description => 'resolve acl', principal =>'ZABBIX', is_grant => true, privilege => 'resolve');

exec dbms_network_acl_admin.assign_acl(acl => 'resolve.xml', host =>'*');

commit;

参考官网文档

http://www.smartmarmot.com/wiki/index.php/Orabbix

编辑刚刚生成的config.props文件

zabbix server 端操作

vi  /opt/orabbix/conf/config.props

** 修改后内容如下 **

#comma separed list of Zabbix servers

ZabbixServerList=ZabbixServer

ZabbixServer.Address=192.168.2.145    **#zabbix server IP地址**

ZabbixServer.Port=10051                        **#端口**

ZabbixServer2.Address=IP_ADDRESS_OF_ZABBIX_SERVER

ZabbixServer2.Port=PORT_OF_ZABBIX_SERVER

#pidFile

OrabbixDaemon.PidFile=./logs/orabbix.pid

#frequency of item's refresh

OrabbixDaemon.Sleep=300

#MaxThreadNumber should be >= than the number of your databases

OrabbixDaemon.MaxThreadNumber=100

#put here your databases in a comma separated list

DatabaseList=192.168.2.142     **# 名称与该机在 zabbix 中监控的主机名称保持一致**

#Configuration of Connection pool

#if not specified Orabbis is going to use default values (hardcoded)

#Maximum number of active connection inside pool

DatabaseList.MaxActive=10

#The maximum number of milliseconds that the pool will wait 

#(when there are no available connections) for a connection to be returned 

#before throwing an exception, or <= 0 to wait indefinitely. 

DatabaseList.MaxWait=100

DatabaseList.MaxIdle=1

#define here your connection string for each database

192.168.2.142.Url=jdbc:oracle:thin:@192.168.2.142:1521:orcl    **# 需要 jdk 环境，因为这里是通过 JDBC 连接的，**

                                                                                                     **#orcl   为数据库实例名称**

192.168.2.142.User=ZABBIX            **# 用来监控 oracle 数据库的用户名和密码，需要在 oracle 中创建并赋予一定的权限**

192.168.2.142.Password=ZABBIX

#Those values are optionals if not specified Orabbix is going to use the general values

192.168.2.142.MaxActive=10

192.168.2.142.MaxWait=100

192.168.2.142.MaxIdle=1

192.168.2.142.QueryListFile=./conf/query.props

#DB2.Url=jdbc:oracle:thin:@server2.domain.example.com:<LISTENER_PORT>:DB2

#DB2.User=zabbix

#DB2.Password=zabbix_password

#DB2.QueryListFile=./conf/query.props

#DB3.Url=jdbc:oracle:thin:@server3.domain.example.com:<LISTENER_PORT>:DB3

#DB3.User=zabbix

#DB3.Password=zabbix_password

#DB3.QueryListFile=./conf/query.props

——————分—————————割—————————线————————

**注：**以上端口号为与Zabbix Server通讯的端口，我这里是将Orabbix与Zabbix server 装在同一台机器上的，如果不在同一台机器，那装Orabbix的机器需要先装Zabbix Agent，否则数据将无法传送到Zabbix Server。

注：

ZabbixServerList：可以设置多个，用",“进行分割；

DatabaseList：可以设置多个被监控的Oracle数据库服务器，用”,“进行分割，该名称要和zabbix server界面中的Host name保持一致，该配置文件中后续所引用的设定都以该名称为准。

关于 JDBC 可参考：

 Oracle     =    jdbc:oracle:thin:@<host>:<LISTENER_PORT>:<instance>

 PostgreSQL  =    jdbc:postgresql://<host>:<port>/<database>

 MS Sql Server =    jdbc:jtds:sqlserver://<host>:<port>/<instancename>

 [MySQL](http://lib.csdn.net/base/mysql) Server =    jdbc:[mysql](http://lib.csdn.net/base/mysql)://[host:port],[host:port].../[database]

 DB2      =    jdbc:db2://<servername>:<port>/<installation>

启动服务

/etc/init.d/orabbix     start
# 或
systemctl  start   orabbix

配置zabbix添加监控

zabbix web 端操作

导入模板

模板在/opt/orabbix/template/ 目录下面，全部导入zabbix web 即可

添加主机

主机名称必须要和配至文件中的databaseLst 中的名称一致

添加oracle 模板

验证

监控库的大小

配置 query.props

默认按照上面的步骤就差不多了，但是你导入模板之后就会发现监控项目不全，如dbsize及dbfilesize这些类目，orabbix默认情况下未开启数据库大小，需要配置query.props

cp  /opt/orabbix/conf/query.props  /opt/orabbix/conf/query.props.bak

vi /opt/orabbix/conf/query.props

在QueryList=类目下增加dbfilesize,dbsize，如图所示

然后在该文件的末尾添加

dbfilesize.Query=select to_char(sum(bytes/1024/1024/10), 'FM99999999999999990') retvalue from dba_data_files

dbsize.Query=SELECT to_char(sum(  NVL(a.bytes/1024/1024/10 - NVL(f.bytes/1024/1024/10, 0), 0)), 'FM99999999999999990') retvalue \

FROM sys.dba_tablespaces d, \

(select tablespace_name, sum(bytes) bytes from dba_data_files group by tablespace_name) a, \

(select tablespace_name, sum(bytes) bytes from dba_free_space group by tablespace_name) f \

WHERE d.tablespace_name = a.tablespace_name(+) AND d.tablespace_name = f.tablespace_name(+) \

AND NOT (d.extent_management like 'LOCAL' AND d.contents like 'TEMPORARY')

用以定义查询dbfilesize,dbsize的SQL语句

添加内容如图所示

注释：语句过长的话要用 \ 来分隔

这个时候就可以启动orabbix服务了

systemctl restart orabbix

检查服务ps aux |grep orabbix|wc -l 如果等于2就说明启动那个成功了

查看日志看是否有报错

/opt/orabbix/logs/orabbix.log

表空间监控的优化

自定义SQL检查

Orabbix提供了表空间的监控，监控项对应的SQL:

vi /opt/orabbix/conf/query.props

tbl_space.Query=SELECT * FROM ( \

select '- Tablespace ->',t.tablespace_name ktablespace, \

'- Type->',substr(t.contents, 1, 1) tipo, \

'- Used(MB)->',trunc((d.tbs_size-nvl(s.free_space, 0))/1024/1024) ktbs_em_uso, \

'- ActualSize(MB)->',trunc(d.tbs_size/1024/1024) ktbs_size, \

'- MaxSize(MB)->',trunc(d.tbs_maxsize/1024/1024) ktbs_maxsize, \

'- FreeSpace(MB)->',trunc(nvl(s.free_space, 0)/1024/1024) kfree_space, \

'- Space->',trunc((d.tbs_maxsize - d.tbs_size + nvl(s.free_space, 0))/1024/1024) kspace, \

'- Perc->',decode(d.tbs_maxsize, 0, 0, trunc((d.tbs_size-nvl(s.free_space, 0))*100/d.tbs_maxsize)) kperc \

from \

( select SUM(bytes) tbs_size, \

SUM(decode(sign(maxbytes - bytes), -1, bytes, maxbytes)) tbs_maxsize, tablespace_name tablespace \

from ( select nvl(bytes, 0) bytes, nvl(maxbytes, 0) maxbytes, tablespace_name \

from dba_data_files \

union all \

select nvl(bytes, 0) bytes, nvl(maxbytes, 0) maxbytes, tablespace_name \

from dba_temp_files \

) \

group by tablespace_name \

) d, \

( select SUM(bytes) free_space, \

tablespace_name tablespace \

from dba_free_space \

group by tablespace_name \

) s, \

dba_tablespaces t \

where t.tablespace_name = d.tablespace(+) and \

t.tablespace_name = s.tablespace(+) \

order by 8) \

where kperc > 93 \

and tipo <>'T' \

and tipo <>'U'

tbl_space.NoDataFound=none

这个SQL会返回93%满的表空间信息，而对应这个监控项，orabbix也定义了触发器，因为监控项的返回值是文本，而没有满足条件的记录时返回字符串“none“，所以监控项对应的触发器会检查返回值开头是不是none，如果不是，就报警，这样，用户除了收到预警信息，还能从返回值的具体值中看到具体时哪个表空间快满了。

当然，大部分时间监控项会返回none，所以我们无法画出正常未满的表空间的空间占用时间曲线。只有超过93%慢时，我们才知道具体的占用情况。

测试

把值调为5的触发效果

参考文档

https://www.cnblogs.com/dujiaxiaoK/p/7719049.html

https://blog.csdn.net/frank0521/article/details/7469457

http://www.zhimengzhe.com/shujuku/other/182171.html

官方文档
http://www.smartmarmot.com/wiki/index.php/Orabbix

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/211009115571/
相关话题：https://www.cnsre.cn/tags/zabbix/

Nginx WebSocket 代理

Wenlong — Thu, 30 Sep 2021 10:10:17 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210930010174/
相关话题：https://www.cnsre.cn/tags/nginx/

为了将客户端和服务器之间的连接从 HTTP/1.1 转换为 WebSocket，使用了 HTTP/1.1 中可用的协议切换机制。

但是由于 Upgrade 是一个 hop-by-hop 标头，它不会从客户端传递到代理服务器。通过正向代理，客户端可以使用该CONNECT 方法来规避此问题。然而，这不适用于反向代理，因为客户端不知道任何代理服务器，并且需要在代理服务器上进行特殊处理。

从 1.3.13 版本开始，nginx 实现了特殊的操作模式，如果代理服务器返回代码为 101（切换协议）的响应，并且客户端通过请求中的 Upgrade 标头。

如上所述，包括 Upgrade 和 Connection 在内的逐跳标头不会从客户端传递到代理服务器，因此为了让代理服务器了解客户端将协议切换到 WebSocket 的意图，这些标头必须明确传递：

location /chat/ {
    proxy_pass http://backend;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
}

一个更复杂的示例，其中对代理服务器的请求中“Connection”标头字段的值取决于客户端请求标头中“Upgrade”字段的存在：

http {
    map $http_upgrade $connection_upgrade {
        default upgrade;
        ''      close;
    }

    server {
        ...

        location /chat/ {
            proxy_pass http://backend;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection $connection_upgrade;
        }
    }

默认情况下，如果代理服务器在 60 秒内没有传输任何数据，连接将被关闭。可以使用proxy_read_timeout指令增加此超时。或者，可以将代理服务器配置为定期发送 WebSocket ping 帧以重置超时并检查连接是否仍然有效。

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210930010174/
相关话题：https://www.cnsre.cn/tags/nginx/

journal log日志的问题

Wenlong — Tue, 28 Sep 2021 09:57:08 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210928957081/
相关话题：https://www.cnsre.cn/tags/故障集/

前言

线上服务器磁盘告警

登录服务器检查磁盘发现一个叫做 journal 的文件夹占用了大量空间。

问题分析

Journald是什么

journal 是 centos7 中 systemd 的一个组件，由 journald处理。捕获系统日志信息、内核日志信息，以及来自原始RAM磁盘的信息，早期启动信息以及所有服务中写入 STDOUT 和 STDERR 数据流的信息。可以说是为 Linux 服务器打造的一种新系统日志方式，这些日志信息写入到二进制文件，使用 journalctl 阅读，默认存放在 /run/log/ 下。

Journald系统主要由三个主要的系统日记服务组件组成：

守护程序：systemd 日志服务由 systemd-journald 守护程序处理。
配置文件：日志服务的配置在 /etc/systemd/journald.conf 里面设置。
日志搜索程序：用于搜索日记日志文件的程序是 journalctl。

journalctl使用

journalctl 常用命令

journalctl               #查看所有日志
journalctl -n 5          #查看最后5条日志
journalctl -p err        #查看err类型的日志
journalctl -f            #不断输出最后10条日志
journalctl --since today #查看今天的日志
journalctl --since "2021-9-28 08:00:00" --until "2021-9-28 09:00:00"
journalctl -o verbose    #查看日志详细信息
journalctl --disk-usage  #检查当前journal使用磁盘量
journalctl --vacuum-time=2d #只保存2天的日志
journalctl --vacuum-size=500M #最大500M
journalctl --verify      #检查journal是否运行正常以及日志文件是否完整无损坏

持久保存日志

由于 journald 默认是保存在内存中，一旦服务器重启，就会丢失，作为生成环境，管理员必须保证系统任何日志不能丢失，通过修改配置文件做持久保存。
同时，systemd-journald.service 的配置文件主要参考 /etc/systemd/journald.conf 的内容，详细的参数可以参考如下

[Journal]
#日志存储到磁盘
Storage=persistent 
#压缩日志
Compress=yes 
#为日志添加序列号
Seal=yes 
#每个用户分别记录日志
SplitMode=uid 
#日志同步到磁盘的间隔，高级别的日志，如：CRIT、ALERT、EMERG 三种总是实时同步
SyncIntervalSec=1m 

#即制日志的最大流量，此处指 30s 内最多记录 100000 条日志，超出的将被丢弃
RateLimitInterval=30s 
#与 RateLimitInterval 配合使用
RateLimitBurst=100000

#限制全部日志文件加在一起最多可以占用多少空间，默认值是10%空间与4G空间两者中的较小者
SystemMaxUse=64G 
#默认值是15%空间与4G空间两者中的较大者
SystemKeepFree=1G 

#单个日志文件的大小限制，超过此限制将触发滚动保存
SystemMaxFileSize=128M 

#日志滚动的最大时间间隔，若不设置则完全以大小限制为准
MaxFileSec=1day
#日志最大保留时间，超过时限的旧日志将被删除
MaxRetentionSec=100year 

#是否转发符合条件的日志记录到本机的其它日志管理系统，如：rsyslog
ForwardToSyslog=yes 
ForwardToKMsg=no
#是否转发符合条件的日志到所有登陆用户的终端
ForwardToWall=yes 
MaxLevelStore=debug 
MaxLevelSyslog=err 
MaxLevelWall=emerg 
ForwardToConsole=no 
#TTYPath=/dev/console
#MaxLevelConsole=info
#MaxLevelKMsg=notice

处理过程

知道了这些，就可以轻松的处理这些日志了。
检查当前journal使用磁盘量

`1`	`journalctl --disk-usage`

清理方法可以采用按照日期清理，或者按照允许保留的容量清理，只保存2天的日志，最大500M

1
2

journalctl --vacuum-time=2d
journalctl --vacuum-size=500M

要启用日志限制持久化配置，可以修改

vim /etc/systemd/journald.conf
SystemMaxUse=16M
ForwardToSyslog=no

# 重启 
systemctl restart systemd-journald.service

检查journal是否运行正常以及日志文件是否完整无损坏

`1`	`journalctl --verify`

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210928957081/
相关话题：https://www.cnsre.cn/tags/故障集/

国外镜像拉取到docker hub

Wenlong — Fri, 24 Sep 2021 09:25:54 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210924925541/
相关话题：https://www.cnsre.cn/tags/docker/

文章链接
在学习K8S 的过程中总，部分镜像需要从 k8s.grc.io 仓库中拉拉取。但是因为网络的问题导致无法拉取狗歌的镜像，也就导致了创建 pod 拉取镜像失败。
今天就跟大家分享下我从国外拉到国内的镜像。

替换规则

同理，其他镜像地址也可以用该 dockerhub 的地址。
具体替换规则：
k8s.gcr.io 替换为 cnsre
ingress-nginx/controller 替换为 ingress-nginx-controller

1
2
3

k8s.gcr.io/ingress-nginx/controller:v1.0.0
# 等同于 
cnsre/ingress-nginx-controller:v1.0.0

举例

比如 ingress 中的镜像地址为 k8s.gcr.io/ingress-nginx/controller:v1.0.0
需要将镜像地址更改为：cnsre/ingress-nginx-controller:v1.0.0

docker pull k8s.gcr.io/ingress-nginx/controller:v1.0.0
# 等同于
docker pull cnsre/ingress-nginx-controller:v1.0.0

dockerhub 中没有的镜像

如果 cnsre 仓库中没有的一些国外镜像需要下载的话，你可以在地址留言(最好在留言中补充邮箱信息，这样你就可以收到通知。)

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210924925541/
相关话题：https://www.cnsre.cn/tags/docker/

kubernetes 部署 metric-server

Wenlong — Wed, 22 Sep 2021 10:13:36 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210922013357/
相关话题：https://www.cnsre.cn/tags/kubernetes/

K8S 使用 kubectl top 看K8S监控
kubectl top 是基础命令，但是需要部署配套的组件才能获取到监控值
部署 metric-server

Kubernetes Metrics Server 是 Cluster 的核心监控数据的聚合器，kubeadm 默认是不部署的。
Metrics Server 供 Dashboard 等其他组件使用，是一个扩展的 APIServer，依赖于 API Aggregator。所以，在安装 Metrics Server 之前需要先在 kube-apiserver 中开启 API Aggregator。
Metrics API 只可以查询当前的度量数据，并不保存历史数据。
Metrics API URI 为 /apis/metrics.k8s.io/，在 k8s.io/metrics 下维护。
必须部署 metrics-server 才能使用该 API，metrics-server 通过调用 kubelet Summary API 获取数据.
不指定pod 名称，则显示命名空间下所有 pod，–containers可以显示 pod 内所有的container
指标含义：
和k8s中的request、limit一致，CPU单位100m=0.1 内存单位1Mi=1024Ki
pod的内存值是其实际使用量，也是做limit限制时判断oom的依据。pod的使用量等于其所有业务容器的总和，不包括 pause 容器，值等于cadvisr中的container_memory_working_set_bytes指标
node的值并不等于该node 上所有 pod 值的总和，也不等于直接在机器上运行 top 或 free 看到的值

要求

注意：使用 Metrics Server 有必备两个条件：

API Server 启用 Aggregator Routing 支持
API Server 能访问 Metrics Server Pod IP
启用API Aggregator

安装 metric-server

下载yaml文件

可以通过运行以下命令下载最新的 Metrics Server 版本：

`1`	`wget https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml`

兼容性：

指标服务器	指标 API 组/版本	支持的 Kubernetes 版本
0.6.x	metrics.k8s.io/v1beta1	*1.19+
0.5.x	metrics.k8s.io/v1beta1	*1.8+
0.4.x	metrics.k8s.io/v1beta1	*1.8+
0.3.x	metrics.k8s.io/v1beta1	1.8-1.21

对于 <1.16 需要--authorization-always-allow-paths=/livez,/readyz

修改镜像地址

国内无法下载 k8s.gcr.io/metrics-server/metrics-server:v0.4.1镜像
需要修改为一下镜像地址

`1`	`cnsre/metrics-server-metrics-server:v0.4.1`

添加 –kubelet-insecure-tls参数

    spec:
      containers:
      - args:
        - --cert-dir=/tmp
        - --secure-port=4443
        - --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname
        - --kubelet-use-node-status-port
        - --kubelet-insecure-tls  # 新增内容

部署metrics-server服务

`1`	`kubectl apply -f components.yaml`

查看状态

1
2
3

[root@master ~]# kubectl -n kube-system get deploy metrics-server
NAME             READY   UP-TO-DATE   AVAILABLE   AGE
metrics-server   1/1     1            1           9m39s

测试

[root@master ~]# kubectl  top  node
NAME     CPU(cores)   CPU%   MEMORY(bytes)   MEMORY%   
master   294m         8%     5971Mi          41%       
node1    198m         5%     3800Mi          26%       
[root@master ~]# kubectl  top  pods 
NAME                                     CPU(cores)   MEMORY(bytes)   
cnsre-deployment-cf6fddb9f-bvfdk         1m           1Mi             
cnsre-deployment-cf6fddb9f-d8spc         1m           1Mi             
cnsre-deployment-cf6fddb9f-nrrhz         1m           1Mi             
nfs-client-provisioner-fd74f99b4-gk8l4   4m           8Mi             
tomcat-deployment-66dc86bb8f-6xj28       2m           974Mi           
tomcat-deployment-66dc86bb8f-db66l       2m           884Mi

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210922013357/
相关话题：https://www.cnsre.cn/tags/kubernetes/

kube-eventer事件监控

Wenlong — Fri, 17 Sep 2021 11:28:05 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210917128049/
相关话题：https://www.cnsre.cn/tags/kubernetes/

下载deployment

我这里保存成kube-event.yaml

# cat kube-event.yaml
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    name: kube-eventer
  name: kube-eventer
  namespace: kube-system
spec:
  replicas: 1
  selector:
    matchLabels:
      app: kube-eventer
  template:
    metadata:
      labels:
        app: kube-eventer
      annotations:
        scheduler.alpha.kubernetes.io/critical-pod: ''
    spec:
      dnsPolicy: ClusterFirstWithHostNet
      serviceAccount: kube-eventer
      containers:
        - image: registry.aliyuncs.com/acs/kube-eventer-amd64:v1.2.0-484d9cd-aliyun
          name: kube-eventer
          command:
            - "/kube-eventer"
            - "--source=kubernetes:https://kubernetes.default"
            ## .e.g,dingtalk sink demo
            #- --sink=dingtalk:[your_webhook_url]&label=[your_cluster_id]&level=[Normal or Warning(default)]
            - --sink=dingtalk:https://oapi.dingtalk.com/robot/send?access_token=355cf0156xxxxxxxxxxxxxxxxxx&level=Warning
          env:
          # If TZ is assigned, set the TZ value as the time zone
          - name: TZ
            value: "Asia/Shanghai"
          volumeMounts:
            - name: localtime
              mountPath: /etc/localtime
              readOnly: true
            - name: zoneinfo
              mountPath: /usr/share/zoneinfo
              readOnly: true
          resources:
            requests:
              cpu: 100m
              memory: 100Mi
            limits:
              cpu: 500m
              memory: 250Mi
      volumes:
        - name: localtime
          hostPath:
            path: /etc/localtime
        - name: zoneinfo
          hostPath:
            path: /usr/share/zoneinfo
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: kube-eventer
rules:
  - apiGroups:
      - ""
    resources:
      - configmaps
      - events
    verbs:
      - get
      - list
      - watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: kube-eventer
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: kube-eventer
subjects:
  - kind: ServiceAccount
    name: kube-eventer
    namespace: kube-system
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: kube-eventer
  namespace: kube-system

钉钉群里创建自定义webhook

设置–智能群助手–添加机器人–选择WeebHook。定义机器人名称和安全设置

安全设置这里我定义了关键字，Waring。创建后复制webhook地址。然后更改上面deployment中的sink处。

我把上面的label删掉了，只留下了level=Waring，刚好对应了我关键字的Waring。只有带有关键字的才会触发告警。

测试告警

然后创建一个测试的Tomcat的deployment，故意把image镜像的tag写错，让他无法拉取镜像

[root@master allenjol]# kubectl apply -f deploy-tomcat-test.yaml
deployment.apps/tomcat-deployment-allenjol created
service/tomcat-service-allenjol created

[root@master allenjol]# kubectl get po
NAME                                        READY   STATUS             RESTARTS   AGE
tomcat-deployment-allenjol-b6687f99-l5vj9   0/1     ImagePullBackOff   0          45s

部署kube-event.yaml并查看日志。可以看到隔30s去检测一次

]# kubectl apply -f kube-event.yaml
]# kubectl get po -n kube-system | grep kube-event


[root@master allenjol]# kubectl logs -f kube-eventer-648f64c985-zfkkg -n kube-system
I0708 09:26:36.409034       1 eventer.go:67] /kube-eventer --source=kubernetes:https://kubernetes.default --sink=dingtalk:https://oapi.dingtalk.com/robot/send?access_token=355cf01569aef206dc6c05681aaf3ed0ea19ed3597db4c26c565dbeb69ce1303&level=Warning
I0708 09:26:36.409191       1 eventer.go:68] kube-eventer version: v1.2.0 commit: 484d9cd
I0708 09:26:36.411557       1 eventer.go:94] Starting with DingTalkSink sink
I0708 09:26:36.411596       1 eventer.go:108] Starting eventer
I0708 09:26:36.411678       1 eventer.go:116] Starting eventer http service
I0708 09:27:00.000163       1 manager.go:102] Exporting 5 events
I0708 09:27:30.000130       1 manager.go:102] Exporting 9 events
I0708 09:28:00.000147       1 manager.go:102] Exporting 1 events
I0708 09:28:30.000150       1 manager.go:102] Exporting 4 events
I0708 09:29:00.000138       1 manager.go:102] Exporting 1 events
...

可以看到这里已经看到了钉钉的webhook地址了，并且还收集到了events。
查看钉钉群，就会看到已经出现了告警了。

其实这个告警当前还存在点问题。个人认为不应该这么频繁发送，应该像prometheus一样可以配置抑制和静默。然后监控时间可以更改。当然熟悉go语言可以自己改源码然后构建成镜像。

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210917128049/
相关话题：https://www.cnsre.cn/tags/kubernetes/

记一次 Ubuntu 内核升级故障处理

Wenlong — Wed, 15 Sep 2021 11:54:43 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210915154434/
相关话题：https://www.cnsre.cn/tags/故障集/

情况介绍

负责的项目下有一批 ubuntu 18.04 的服务器在 AWS 上，因为安全的问题，需要把内核从 5.3.0 升级到 5.4.0。

首次升级为测试环境测两台都是ubuntu 18.04 的版本内核也都为5.3.0。第一台升级进展很顺利。软件更新，然后内核进行单独升级。等到需要重启的时候出现了问题。

处理问题及解决思路

问题1

无法挂载磁盘

首先遇到的第一个问题

解决思路：

升级内核导致 boot 空间越来越小，然后导致无法引导进入系统。因为之前遇到过boot空间占满的情况。但是那是在 kvm 的 vm 中，可以通过 VNC 进行链接修复。这在 aws 上怎么办？

解决方法：

一开始我选择了将改服务器的根磁盘取消挂载。然后挂载到同一可用区的其他服务器上，进行修复。因为磁盘格式的问题，始终挂载不上，为了避免浪费时间，只能以快照恢复的方式将根磁盘进行扩容。

以快照的方式恢复了回复，在快照恢复的过程中将根磁盘扩容的方法果然将服务器运行起来了。

后面就接着尝试进行内核升级….

问题2

内核升级数据库依赖报错？

具体内容如下：

解决思路：

这个问题，真的是没有思路。处理了很久，都没有解决这个问题。还希望有思路的能到指导下。

解决方法:

为了快速解决内核升级的问题，我将 mysql 以及相关的依赖都卸载掉了。

问题3

升级完重启失败？

这个问题也是最大的问题，最明显的表现就是。升级没有报错，但是升级完需要重启，服务器进行重启的时候无法进入操作系统。

此时已经是凌晨4点多钟了，已经很迷糊了。然后就把服务器恢复到升级内核前的样子。打算明天启动快照进行复现。

解决思路：

又是挂载失败？怎么又会遇到挂载失败呢？最后发现重启自动挂载磁盘的配置并没有按照官方的指示去做使用UUID的配置开启挂载盘符。从而系统会检测磁盘的过程中会检测到该错误。无法正常进如系统。

解决方法：

如果是物理机，或者是可以通过其他方式进行控制引导的话还可以修复。但是云主机怎么修复呢？只能去修复磁盘了

在云主机上有两种访问磁盘卷的方法

方法 1：使用 EC2 控制台

（摘自 AWS 文档）

如果您为 Linux 启用了 EC2 串行控制台，则可以使用它来排查受支持的基于 Nitro 的实例类型问题。串行控制台可帮助您排查启动问题、网络配置和 SSH 配置问题。串行控制台无需网络连接即可连接到您的实例。您可以使用 Amazon EC2 控制台或 AWS 命令行界面 (AWS CLI) 访问串行控制台。

在使用串行控制台之前，请在账户层面授予对串行控制台的访问权限。然后，创建 AWS Identity and Access Management (IAM) 策略，授予对 IAM 用户的访问权限。此外，每个使用串行控制台的实例都必须至少包含一个基于密码的用户。如果您的实例无法访问，并且尚未配置对串行控制台的访问权限，请按照方法 2 中的说明进行操作。有关为 Linux 配置 EC2 串行控制台的信息，请参阅配置对 EC2 串行控制台的访问权限。

注意：如果在运行 AWS CLI 命令时遇到错误，请确保您使用的是最新版本的 AWS CLI。

方法 2：挂载到其他实例上

创建一个临时救援实例，然后将您的 Amazon Elastic Block Store (Amazon EBS) 卷重新挂载到该救援实例上。从该救援实例中，您可以将 GRUB 配置为使用以前的内核进行启动。

**重要提示：**请勿在实例存储支持的实例上执行此操作。由于此恢复方法需要首先停止然后再重启实例，该实例上的任何数据都将丢失。有关更多信息，请参阅确定实例的根设备类型。

为根卷创建 EBS 快照。有关更多信息，请参阅创建 Amazon EBS 快照。
打开 Amazon EC2 控制台。
注意： 请确保您位于正确的区域。
从导航窗格中选择实例，然后选择受损的实例。
选择 Instance State（实例状态）、Stop Instance（停止实例），然后选择 Stop（停止）。
在 **Storage（存储）**选项卡的 **Block devices（块储存设备）**下，为 /dev/sda1 或 /dev/xvda 选择 Volume ID（卷 ID）。
依次选择操作、 断开卷 ，然后选择 是，请分离 。记下可用区。
在同一可用区中启动一个救援 EC2 实例。
启动救援实例后，从导航窗格中选择卷，然后选择受损实例已分离的根卷。
依次选择操作、附加卷 。
选择救援实例 ID (id-xxxxx)，然后设置一个未使用的设备。在本示例中为 /dev/sdf。
使用 SSH 连接到救援实例。
运行 lsblk 命令以查看可用的磁盘设备：

lsblk
# 输出如下：
xvda    202:0    0   20G  0 disk 
└─xvda1 202:1    0   20G  0 part /
xvdb    202:16   0  100G  0 disk 
xvdf    202:80   0   15G  0 disk 
└─xvdf1 202:81   0   15G  0 part    # 该磁盘为故障集服务器根磁盘

查看磁盘格式

lsblk -f
NAME    FSTYPE   LABEL           UUID                                 MOUNTPOINT
xvda                                                                  
└─xvda1 ext4     cloudimg-rootfs d32458a7-7f4c-415f-9a66-b579f14fb82d /
xvdb    ext4                     eb0e325a-471c-4a99-a9be-a3ee296c2405 
xvdf                                                                  
└─xvdf1 ext4     cloudimg-rootfs d32458a7-7f4c-415f-9a66-b579f14fb82d

挂载磁盘

sudo -i
mount  /dev/xvdf1  /mnt

然后查看挂载目录，发现根磁盘已经挂载到了mnt下

查看配置文件

ubuntu@ip-10-0-20-27:~$  cat /etc/fstab 
LABEL=cloudimg-rootfs   /        ext4   defaults,discard        0 0
/dev/nvme0n1        /data   ext4    defaults        0       0

查看官网挂载文档如下：

重启后自动挂载附加的卷

(摘自AWS 官方文档)

要在每次系统重启时附加附加的 EBS 卷，可在 /etc/fstab 文件中为该设备添加一个条目。

您可以在 /dev/xvdf 中使用设备名称（如 /etc/fstab），但建议改为使用设备的 128 位通用唯一标识符 (UUID)。设备名称可以更改，但 UUID 会在整个分区的使用寿命期间保留。通过使用 UUID，您可以减少系统在硬件重新配置后无法启动的机会。有关更多信息，请参阅识别 EBS 设备。

重启后自动附加附加卷

（可选）创建 /etc/fstab 文件的备份，以便在编辑时误损坏或删除此文件时使用。
```
[ec2-user ~]$ sudo cp /etc/fstab /etc/fstab.orig
```
使用 blkid 命令查找设备的 UUID。记下要在重新启动后挂载的设备的 UUID。在下一步中您将需要用到它。

例如，以下命令显示有两个设备挂载到实例上，并显示了两个设备的 UUID。
```
[ec2-user ~]$ sudo blkid
/dev/xvda1: LABEL="/" UUID="ca774df7-756d-4261-a3f1-76038323e572" TYPE="xfs" PARTLABEL="Linux" PARTUUID="02dcd367-e87c-4f2e-9a72-a3cf8f299c10"
/dev/xvdf: UUID="aebf131c-6957-451e-8d34-ec978d9581ae" TYPE="xfs"
```
对于 Ubuntu 18.04，请使用 lsblk 命令。
```
[ec2-user ~]$ sudo lsblk -o +UUID
```
使用任何文本编辑器（如 /etc/fstab 和 nano）打开 vim 文件。
```
[ec2-user ~]$ sudo vim /etc/fstab
```
将以下条目添加到 /etc/fstab 以在指定的挂载点挂载设备。这些字段是 blkid（或用于 Ubuntu 18.04 的 lsblk）返回的 UUID 值、挂载点、文件系统以及建议的文件系统挂载选项。有关必填字段的更多信息，请运行 man fstab 以打开 fstab 手册。

在以下示例中，我们将 UUID 为 aebf131c-6957-451e-8d34-ec978d9581ae 的设备挂载到挂载点 /data，然后我们使用 xfs 文件系统。我们还使用 defaults 和 nofail 标志。我们指定 0 以防止文件系统被转储，并且我们指定 2 以指示它是非根设备。
```
UUID=aebf131c-6957-451e-8d34-ec978d9581ae  /data  xfs  defaults,nofail  0  2
```
注意

如果您要在未附加此卷的情况下启动实例（例如，将卷移动到另一个实例之后），nofail 附加选项允许该实例即使在卷附加过程中出现错误时也可启动。Debian 衍生物 (包括早于 16.04 的 Ubuntu 版本) 还必须添加 nobootwait 挂载选项。
要检查条目是否有效，请在 /etc/fstab 中运行以下命令以卸载设备，然后挂载所有文件系统。如果未产生错误，则说明 /etc/fstab 文件正常，您的文件系统会在重启后自动挂载。
```
[ec2-user ~]$ sudo umount /data
[ec2-user ~]$ sudo mount -a
```
如果收到错误消息，请解决文件中的错误。

警告

/etc/fstab 文件中的错误可能显示系统无法启动。请勿关闭 /etc/fstab 文件中有错误的系统。

如果您无法确定如何更正 /etc/fstab 中的错误并且您在此过程的第一步中创建了一个备份文件，则可以使用以下命令从您的备份文件还原。
```
[ec2-user ~]$ sudo mv /etc/fstab.orig /etc/fstab
```

查看修改日期核对修改时间

问题都解决了。接下来继续升级内核吧。

sudo apt-get install linux-image-5.4.0-1055-aws

等待重启查看

终于成功了。。。

问题总结

问题1
更新内核导致引导分区存储占满。
优化
在ubuntu 进行内核补丁软件更新时需要注意boot、root分区的容量。以避免重启后无法正常引导进入系统。
问题2
更新下载软件，提示 were encountered while processing
优化
后测试发现更新下载任何软件都会出现这种情况，暂未解决。
问题3
磁盘开机自动挂载配置问题。
优化
以后需要严格按照 AWS 官方文档来进行操作部署，以免再次遇到类似的事情发生。

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210915154434/
相关话题：https://www.cnsre.cn/tags/故障集/

CentOS 7 OpenVPN 脚本

Wenlong — Mon, 13 Sep 2021 09:32:52 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210913932516/
相关话题：https://www.cnsre.cn/tags/故障集/

为了避免数据库服务器等内网应用资源暴露到公网中，打算利用VPN 技术实现链接到内网。
本文主要介绍CentOS 7 服务器上安装与配置OpenVPN服务器,以及如何编写客户端连接到新建立的OpenVPN服务器上所需的配置文件

OpenVPN的介绍

OpenVPN是一个开源的应用程序，它允许您通过公共互联网创建一个安全的专用网络。OpenVPN实现一个虚拟专用网（VPN）来创建一个安全连接。OpenVPN使用OpenSSL库提供加密，它提供了几种身份验证机制，如基于证书的、预共享密钥和用户名/密码身份验证。

openvpn 有两种模式

数据包（TUN模式）或数据帧（TAP模式）

TUN模式：TUN模拟了网络层设备，第三层数据包如IP封包，底层数据隧道数据
TAP模式等同于一个设备，第二操作层数据包如扩展数据帧，创建一个相对桥接接，复杂T

接口接口的好处可见，客户端优化VPN服务子网的IP（忽然忽隐忽现）物理上的区别，可以完全将客户端看做完全与VPN服务器相关的时间，而TUN接口下所有的客户端则出现一个独立的子网内，与VPN服务器相关的子网没有关系，这种使用比较好，和公司的网络区分开，完全是一个虚拟的网络

脚本内容

openvpn 一键安装脚本

#!/bin/bash
#
# https://github.com/Nyr/openvpn-install
#
# Copyright (c) 2013 Nyr. Released under the MIT License.


# Detect Debian users running the script with "sh" instead of bash
if readlink /proc/$$/exe | grep -q "dash"; then
	echo 'This installer needs to be run with "bash", not "sh".'
	exit
fi

# Discard stdin. Needed when running from an one-liner which includes a newline
read -N 999999 -t 0.001

# Detect OpenVZ 6
if [[ $(uname -r | cut -d "." -f 1) -eq 2 ]]; then
	echo "The system is running an old kernel, which is incompatible with this installer."
	exit
fi

# Detect OS
# $os_version variables aren't always in use, but are kept here for convenience
if grep -qs "ubuntu" /etc/os-release; then
	os="ubuntu"
	os_version=$(grep 'VERSION_ID' /etc/os-release | cut -d '"' -f 2 | tr -d '.')
	group_name="nogroup"
elif [[ -e /etc/debian_version ]]; then
	os="debian"
	os_version=$(grep -oE '[0-9]+' /etc/debian_version | head -1)
	group_name="nogroup"
elif [[ -e /etc/centos-release ]]; then
	os="centos"
	os_version=$(grep -oE '[0-9]+' /etc/centos-release | head -1)
	group_name="nobody"
elif [[ -e /etc/fedora-release ]]; then
	os="fedora"
	os_version=$(grep -oE '[0-9]+' /etc/fedora-release | head -1)
	group_name="nobody"
else
	echo "This installer seems to be running on an unsupported distribution.
Supported distributions are Ubuntu, Debian, CentOS, and Fedora."
	exit
fi

if [[ "$os" == "ubuntu" && "$os_version" -lt 1804 ]]; then
	echo "Ubuntu 18.04 or higher is required to use this installer.
This version of Ubuntu is too old and unsupported."
	exit
fi

if [[ "$os" == "debian" && "$os_version" -lt 9 ]]; then
	echo "Debian 9 or higher is required to use this installer.
This version of Debian is too old and unsupported."
	exit
fi

if [[ "$os" == "centos" && "$os_version" -lt 7 ]]; then
	echo "CentOS 7 or higher is required to use this installer.
This version of CentOS is too old and unsupported."
	exit
fi

# Detect environments where $PATH does not include the sbin directories
if ! grep -q sbin <<< "$PATH"; then
	echo '$PATH does not include sbin. Try using "su -" instead of "su".'
	exit
fi

if [[ "$EUID" -ne 0 ]]; then
	echo "This installer needs to be run with superuser privileges."
	exit
fi

if [[ ! -e /dev/net/tun ]] || ! ( exec 7<>/dev/net/tun ) 2>/dev/null; then
	echo "The system does not have the TUN device available.
TUN needs to be enabled before running this installer."
	exit
fi

new_client () {
	# Generates the custom client.ovpn
	{
	cat /etc/openvpn/server/client-common.txt
	echo "<ca>"
	cat /etc/openvpn/server/easy-rsa/pki/ca.crt
	echo "</ca>"
	echo "<cert>"
	sed -ne '/BEGIN CERTIFICATE/,$ p' /etc/openvpn/server/easy-rsa/pki/issued/"$client".crt
	echo "</cert>"
	echo "<key>"
	cat /etc/openvpn/server/easy-rsa/pki/private/"$client".key
	echo "</key>"
	echo "<tls-crypt>"
	sed -ne '/BEGIN OpenVPN Static key/,$ p' /etc/openvpn/server/tc.key
	echo "</tls-crypt>"
	} > ~/"$client".ovpn
}

if [[ ! -e /etc/openvpn/server/server.conf ]]; then
	clear
	echo 'Welcome to this OpenVPN road warrior installer!'
	# If system has a single IPv4, it is selected automatically. Else, ask the user
	if [[ $(ip -4 addr | grep inet | grep -vEc '127(\.[0-9]{1,3}){3}') -eq 1 ]]; then
		ip=$(ip -4 addr | grep inet | grep -vE '127(\.[0-9]{1,3}){3}' | cut -d '/' -f 1 | grep -oE '[0-9]{1,3}(\.[0-9]{1,3}){3}')
	else
		number_of_ip=$(ip -4 addr | grep inet | grep -vEc '127(\.[0-9]{1,3}){3}')
		echo
		echo "Which IPv4 address should be used?"
		ip -4 addr | grep inet | grep -vE '127(\.[0-9]{1,3}){3}' | cut -d '/' -f 1 | grep -oE '[0-9]{1,3}(\.[0-9]{1,3}){3}' | nl -s ') '
		read -p "IPv4 address [1]: " ip_number
		until [[ -z "$ip_number" || "$ip_number" =~ ^[0-9]+$ && "$ip_number" -le "$number_of_ip" ]]; do
			echo "$ip_number: invalid selection."
			read -p "IPv4 address [1]: " ip_number
		done
		[[ -z "$ip_number" ]] && ip_number="1"
		ip=$(ip -4 addr | grep inet | grep -vE '127(\.[0-9]{1,3}){3}' | cut -d '/' -f 1 | grep -oE '[0-9]{1,3}(\.[0-9]{1,3}){3}' | sed -n "$ip_number"p)
	fi
	# If $ip is a private IP address, the server must be behind NAT
	if echo "$ip" | grep -qE '^(10\.|172\.1[6789]\.|172\.2[0-9]\.|172\.3[01]\.|192\.168)'; then
		echo
		echo "This server is behind NAT. What is the public IPv4 address or hostname?"
		# Get public IP and sanitize with grep
		get_public_ip=$(grep -m 1 -oE '^[0-9]{1,3}(\.[0-9]{1,3}){3}$' <<< "$(wget -T 10 -t 1 -4qO- "http://ip1.dynupdate.no-ip.com/" || curl -m 10 -4Ls "http://ip1.dynupdate.no-ip.com/")")
		read -p "Public IPv4 address / hostname [$get_public_ip]: " public_ip
		# If the checkip service is unavailable and user didn't provide input, ask again
		until [[ -n "$get_public_ip" || -n "$public_ip" ]]; do
			echo "Invalid input."
			read -p "Public IPv4 address / hostname: " public_ip
		done
		[[ -z "$public_ip" ]] && public_ip="$get_public_ip"
	fi
	# If system has a single IPv6, it is selected automatically
	if [[ $(ip -6 addr | grep -c 'inet6 [23]') -eq 1 ]]; then
		ip6=$(ip -6 addr | grep 'inet6 [23]' | cut -d '/' -f 1 | grep -oE '([0-9a-fA-F]{0,4}:){1,7}[0-9a-fA-F]{0,4}')
	fi
	# If system has multiple IPv6, ask the user to select one
	if [[ $(ip -6 addr | grep -c 'inet6 [23]') -gt 1 ]]; then
		number_of_ip6=$(ip -6 addr | grep -c 'inet6 [23]')
		echo
		echo "Which IPv6 address should be used?"
		ip -6 addr | grep 'inet6 [23]' | cut -d '/' -f 1 | grep -oE '([0-9a-fA-F]{0,4}:){1,7}[0-9a-fA-F]{0,4}' | nl -s ') '
		read -p "IPv6 address [1]: " ip6_number
		until [[ -z "$ip6_number" || "$ip6_number" =~ ^[0-9]+$ && "$ip6_number" -le "$number_of_ip6" ]]; do
			echo "$ip6_number: invalid selection."
			read -p "IPv6 address [1]: " ip6_number
		done
		[[ -z "$ip6_number" ]] && ip6_number="1"
		ip6=$(ip -6 addr | grep 'inet6 [23]' | cut -d '/' -f 1 | grep -oE '([0-9a-fA-F]{0,4}:){1,7}[0-9a-fA-F]{0,4}' | sed -n "$ip6_number"p)
	fi
	echo
	echo "Which protocol should OpenVPN use?"
	echo "   1) UDP (recommended)"
	echo "   2) TCP"
	read -p "Protocol [1]: " protocol
	until [[ -z "$protocol" || "$protocol" =~ ^[12]$ ]]; do
		echo "$protocol: invalid selection."
		read -p "Protocol [1]: " protocol
	done
	case "$protocol" in
		1|"") 
		protocol=udp
		;;
		2) 
		protocol=tcp
		;;
	esac
	echo
	echo "What port should OpenVPN listen to?"
	read -p "Port [1194]: " port
	until [[ -z "$port" || "$port" =~ ^[0-9]+$ && "$port" -le 65535 ]]; do
		echo "$port: invalid port."
		read -p "Port [1194]: " port
	done
	[[ -z "$port" ]] && port="1194"
	echo
	echo "Select a DNS server for the clients:"
	echo "   1) Current system resolvers"
	echo "   2) Google"
	echo "   3) 1.1.1.1"
	echo "   4) OpenDNS"
	echo "   5) Quad9"
	echo "   6) AdGuard"
	read -p "DNS server [1]: " dns
	until [[ -z "$dns" || "$dns" =~ ^[1-6]$ ]]; do
		echo "$dns: invalid selection."
		read -p "DNS server [1]: " dns
	done
	echo
	echo "Enter a name for the first client:"
	read -p "Name [client]: " unsanitized_client
	# Allow a limited set of characters to avoid conflicts
	client=$(sed 's/[^0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-]/_/g' <<< "$unsanitized_client")
	[[ -z "$client" ]] && client="client"
	echo
	echo "OpenVPN installation is ready to begin."
	# Install a firewall in the rare case where one is not already available
	if ! systemctl is-active --quiet firewalld.service && ! hash iptables 2>/dev/null; then
		if [[ "$os" == "centos" || "$os" == "fedora" ]]; then
			firewall="firewalld"
			# We don't want to silently enable firewalld, so we give a subtle warning
			# If the user continues, firewalld will be installed and enabled during setup
			echo "firewalld, which is required to manage routing tables, will also be installed."
		elif [[ "$os" == "debian" || "$os" == "ubuntu" ]]; then
			# iptables is way less invasive than firewalld so no warning is given
			firewall="iptables"
		fi
	fi
	read -n1 -r -p "Press any key to continue..."
	# If running inside a container, disable LimitNPROC to prevent conflicts
	if systemd-detect-virt -cq; then
		mkdir /etc/systemd/system/openvpn-server@server.service.d/ 2>/dev/null
		echo "[Service]
LimitNPROC=infinity" > /etc/systemd/system/openvpn-server@server.service.d/disable-limitnproc.conf
	fi
	if [[ "$os" = "debian" || "$os" = "ubuntu" ]]; then
		apt-get update
		apt-get install -y openvpn openssl ca-certificates $firewall
	elif [[ "$os" = "centos" ]]; then
		yum install -y epel-release
		yum install -y openvpn openssl ca-certificates tar $firewall
	else
		# Else, OS must be Fedora
		dnf install -y openvpn openssl ca-certificates tar $firewall
	fi
	# If firewalld was just installed, enable it
	if [[ "$firewall" == "firewalld" ]]; then
		systemctl enable --now firewalld.service
	fi
	# Get easy-rsa
	easy_rsa_url='https://github.com/OpenVPN/easy-rsa/releases/download/v3.0.8/EasyRSA-3.0.8.tgz'
	mkdir -p /etc/openvpn/server/easy-rsa/
	{ wget -qO- "$easy_rsa_url" 2>/dev/null || curl -sL "$easy_rsa_url" ; } | tar xz -C /etc/openvpn/server/easy-rsa/ --strip-components 1
	chown -R root:root /etc/openvpn/server/easy-rsa/
	cd /etc/openvpn/server/easy-rsa/
	# Create the PKI, set up the CA and the server and client certificates
	./easyrsa init-pki
	./easyrsa --batch build-ca nopass
	EASYRSA_CERT_EXPIRE=3650 ./easyrsa build-server-full server nopass
	EASYRSA_CERT_EXPIRE=3650 ./easyrsa build-client-full "$client" nopass
	EASYRSA_CRL_DAYS=3650 ./easyrsa gen-crl
	# Move the stuff we need
	cp pki/ca.crt pki/private/ca.key pki/issued/server.crt pki/private/server.key pki/crl.pem /etc/openvpn/server
	# CRL is read with each client connection, while OpenVPN is dropped to nobody
	chown nobody:"$group_name" /etc/openvpn/server/crl.pem
	# Without +x in the directory, OpenVPN can't run a stat() on the CRL file
	chmod o+x /etc/openvpn/server/
	# Generate key for tls-crypt
	openvpn --genkey --secret /etc/openvpn/server/tc.key
	# Create the DH parameters file using the predefined ffdhe2048 group
	echo '-----BEGIN DH PARAMETERS-----
MIIBCAKCAQEA//////////+t+FRYortKmq/cViAnPTzx2LnFg84tNpWp4TZBFGQz
+8yTnc4kmz75fS/jY2MMddj2gbICrsRhetPfHtXV/WVhJDP1H18GbtCFY2VVPe0a
87VXE15/V8k1mE8McODmi3fipona8+/och3xWKE2rec1MKzKT0g6eXq8CrGCsyT7
YdEIqUuyyOP7uWrat2DX9GgdT0Kj3jlN9K5W7edjcrsZCwenyO4KbXCeAvzhzffi
7MA0BM0oNC9hkXL+nOmFg/+OTxIy7vKBg8P+OxtMb61zO7X8vC7CIAXFjvGDfRaD
ssbzSibBsu/6iGtCOGEoXJf//////////wIBAg==
-----END DH PARAMETERS-----' > /etc/openvpn/server/dh.pem
	# Generate server.conf
	echo "local $ip
port $port
proto $protocol
dev tun
ca ca.crt
cert server.crt
key server.key
dh dh.pem
auth SHA512
tls-crypt tc.key
topology subnet
server 10.8.0.0 255.255.255.0" > /etc/openvpn/server/server.conf
	# IPv6
	if [[ -z "$ip6" ]]; then
		echo 'push "redirect-gateway def1 bypass-dhcp"' >> /etc/openvpn/server/server.conf
	else
		echo 'server-ipv6 fddd:1194:1194:1194::/64' >> /etc/openvpn/server/server.conf
		echo 'push "redirect-gateway def1 ipv6 bypass-dhcp"' >> /etc/openvpn/server/server.conf
	fi
	echo 'ifconfig-pool-persist ipp.txt' >> /etc/openvpn/server/server.conf
	# DNS
	case "$dns" in
		1|"")
			# Locate the proper resolv.conf
			# Needed for systems running systemd-resolved
			if grep -q '^nameserver 127.0.0.53' "/etc/resolv.conf"; then
				resolv_conf="/run/systemd/resolve/resolv.conf"
			else
				resolv_conf="/etc/resolv.conf"
			fi
			# Obtain the resolvers from resolv.conf and use them for OpenVPN
			grep -v '^#\|^;' "$resolv_conf" | grep '^nameserver' | grep -oE '[0-9]{1,3}(\.[0-9]{1,3}){3}' | while read line; do
				echo "push \"dhcp-option DNS $line\"" >> /etc/openvpn/server/server.conf
			done
		;;
		2)
			echo 'push "dhcp-option DNS 8.8.8.8"' >> /etc/openvpn/server/server.conf
			echo 'push "dhcp-option DNS 8.8.4.4"' >> /etc/openvpn/server/server.conf
		;;
		3)
			echo 'push "dhcp-option DNS 1.1.1.1"' >> /etc/openvpn/server/server.conf
			echo 'push "dhcp-option DNS 1.0.0.1"' >> /etc/openvpn/server/server.conf
		;;
		4)
			echo 'push "dhcp-option DNS 208.67.222.222"' >> /etc/openvpn/server/server.conf
			echo 'push "dhcp-option DNS 208.67.220.220"' >> /etc/openvpn/server/server.conf
		;;
		5)
			echo 'push "dhcp-option DNS 9.9.9.9"' >> /etc/openvpn/server/server.conf
			echo 'push "dhcp-option DNS 149.112.112.112"' >> /etc/openvpn/server/server.conf
		;;
		6)
			echo 'push "dhcp-option DNS 94.140.14.14"' >> /etc/openvpn/server/server.conf
			echo 'push "dhcp-option DNS 94.140.15.15"' >> /etc/openvpn/server/server.conf
		;;
	esac
	echo "keepalive 10 120
cipher AES-256-CBC
user nobody
group $group_name
persist-key
persist-tun
verb 3
crl-verify crl.pem" >> /etc/openvpn/server/server.conf
	if [[ "$protocol" = "udp" ]]; then
		echo "explicit-exit-notify" >> /etc/openvpn/server/server.conf
	fi
	# Enable net.ipv4.ip_forward for the system
	echo 'net.ipv4.ip_forward=1' > /etc/sysctl.d/99-openvpn-forward.conf
	# Enable without waiting for a reboot or service restart
	echo 1 > /proc/sys/net/ipv4/ip_forward
	if [[ -n "$ip6" ]]; then
		# Enable net.ipv6.conf.all.forwarding for the system
		echo "net.ipv6.conf.all.forwarding=1" >> /etc/sysctl.d/99-openvpn-forward.conf
		# Enable without waiting for a reboot or service restart
		echo 1 > /proc/sys/net/ipv6/conf/all/forwarding
	fi
	if systemctl is-active --quiet firewalld.service; then
		# Using both permanent and not permanent rules to avoid a firewalld
		# reload.
		# We don't use --add-service=openvpn because that would only work with
		# the default port and protocol.
		firewall-cmd --add-port="$port"/"$protocol"
		firewall-cmd --zone=trusted --add-source=10.8.0.0/24
		firewall-cmd --permanent --add-port="$port"/"$protocol"
		firewall-cmd --permanent --zone=trusted --add-source=10.8.0.0/24
		# Set NAT for the VPN subnet
		firewall-cmd --direct --add-rule ipv4 nat POSTROUTING 0 -s 10.8.0.0/24 ! -d 10.8.0.0/24 -j SNAT --to "$ip"
		firewall-cmd --permanent --direct --add-rule ipv4 nat POSTROUTING 0 -s 10.8.0.0/24 ! -d 10.8.0.0/24 -j SNAT --to "$ip"
		if [[ -n "$ip6" ]]; then
			firewall-cmd --zone=trusted --add-source=fddd:1194:1194:1194::/64
			firewall-cmd --permanent --zone=trusted --add-source=fddd:1194:1194:1194::/64
			firewall-cmd --direct --add-rule ipv6 nat POSTROUTING 0 -s fddd:1194:1194:1194::/64 ! -d fddd:1194:1194:1194::/64 -j SNAT --to "$ip6"
			firewall-cmd --permanent --direct --add-rule ipv6 nat POSTROUTING 0 -s fddd:1194:1194:1194::/64 ! -d fddd:1194:1194:1194::/64 -j SNAT --to "$ip6"
		fi
	else
		# Create a service to set up persistent iptables rules
		iptables_path=$(command -v iptables)
		ip6tables_path=$(command -v ip6tables)
		# nf_tables is not available as standard in OVZ kernels. So use iptables-legacy
		# if we are in OVZ, with a nf_tables backend and iptables-legacy is available.
		if [[ $(systemd-detect-virt) == "openvz" ]] && readlink -f "$(command -v iptables)" | grep -q "nft" && hash iptables-legacy 2>/dev/null; then
			iptables_path=$(command -v iptables-legacy)
			ip6tables_path=$(command -v ip6tables-legacy)
		fi
		echo "[Unit]
Before=network.target
[Service]
Type=oneshot
ExecStart=$iptables_path -t nat -A POSTROUTING -s 10.8.0.0/24 ! -d 10.8.0.0/24 -j SNAT --to $ip
ExecStart=$iptables_path -I INPUT -p $protocol --dport $port -j ACCEPT
ExecStart=$iptables_path -I FORWARD -s 10.8.0.0/24 -j ACCEPT
ExecStart=$iptables_path -I FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT
ExecStop=$iptables_path -t nat -D POSTROUTING -s 10.8.0.0/24 ! -d 10.8.0.0/24 -j SNAT --to $ip
ExecStop=$iptables_path -D INPUT -p $protocol --dport $port -j ACCEPT
ExecStop=$iptables_path -D FORWARD -s 10.8.0.0/24 -j ACCEPT
ExecStop=$iptables_path -D FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT" > /etc/systemd/system/openvpn-iptables.service
		if [[ -n "$ip6" ]]; then
			echo "ExecStart=$ip6tables_path -t nat -A POSTROUTING -s fddd:1194:1194:1194::/64 ! -d fddd:1194:1194:1194::/64 -j SNAT --to $ip6
ExecStart=$ip6tables_path -I FORWARD -s fddd:1194:1194:1194::/64 -j ACCEPT
ExecStart=$ip6tables_path -I FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT
ExecStop=$ip6tables_path -t nat -D POSTROUTING -s fddd:1194:1194:1194::/64 ! -d fddd:1194:1194:1194::/64 -j SNAT --to $ip6
ExecStop=$ip6tables_path -D FORWARD -s fddd:1194:1194:1194::/64 -j ACCEPT
ExecStop=$ip6tables_path -D FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT" >> /etc/systemd/system/openvpn-iptables.service
		fi
		echo "RemainAfterExit=yes
[Install]
WantedBy=multi-user.target" >> /etc/systemd/system/openvpn-iptables.service
		systemctl enable --now openvpn-iptables.service
	fi
	# If SELinux is enabled and a custom port was selected, we need this
	if sestatus 2>/dev/null | grep "Current mode" | grep -q "enforcing" && [[ "$port" != 1194 ]]; then
		# Install semanage if not already present
		if ! hash semanage 2>/dev/null; then
			if [[ "$os_version" -eq 7 ]]; then
				# Centos 7
				yum install -y policycoreutils-python
			else
				# CentOS 8 or Fedora
				dnf install -y policycoreutils-python-utils
			fi
		fi
		semanage port -a -t openvpn_port_t -p "$protocol" "$port"
	fi
	# If the server is behind NAT, use the correct IP address
	[[ -n "$public_ip" ]] && ip="$public_ip"
	# client-common.txt is created so we have a template to add further users later
	echo "client
dev tun
proto $protocol
remote $ip $port
resolv-retry infinite
nobind
persist-key
persist-tun
remote-cert-tls server
auth SHA512
cipher AES-256-CBC
ignore-unknown-option block-outside-dns
block-outside-dns
verb 3" > /etc/openvpn/server/client-common.txt
	# Enable and start the OpenVPN service
	systemctl enable --now openvpn-server@server.service
	# Generates the custom client.ovpn
	new_client
	echo
	echo "Finished!"
	echo
	echo "The client configuration is available in:" ~/"$client.ovpn"
	echo "New clients can be added by running this script again."
else
	clear
	echo "OpenVPN is already installed."
	echo
	echo "Select an option:"
	echo "   1) Add a new client"
	echo "   2) Revoke an existing client"
	echo "   3) Remove OpenVPN"
	echo "   4) Exit"
	read -p "Option: " option
	until [[ "$option" =~ ^[1-4]$ ]]; do
		echo "$option: invalid selection."
		read -p "Option: " option
	done
	case "$option" in
		1)
			echo
			echo "Provide a name for the client:"
			read -p "Name: " unsanitized_client
			client=$(sed 's/[^0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-]/_/g' <<< "$unsanitized_client")
			while [[ -z "$client" || -e /etc/openvpn/server/easy-rsa/pki/issued/"$client".crt ]]; do
				echo "$client: invalid name."
				read -p "Name: " unsanitized_client
				client=$(sed 's/[^0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-]/_/g' <<< "$unsanitized_client")
			done
			cd /etc/openvpn/server/easy-rsa/
			EASYRSA_CERT_EXPIRE=3650 ./easyrsa build-client-full "$client" nopass
			# Generates the custom client.ovpn
			new_client
			echo
			echo "$client added. Configuration available in:" ~/"$client.ovpn"
			exit
		;;
		2)
			# This option could be documented a bit better and maybe even be simplified
			# ...but what can I say, I want some sleep too
			number_of_clients=$(tail -n +2 /etc/openvpn/server/easy-rsa/pki/index.txt | grep -c "^V")
			if [[ "$number_of_clients" = 0 ]]; then
				echo
				echo "There are no existing clients!"
				exit
			fi
			echo
			echo "Select the client to revoke:"
			tail -n +2 /etc/openvpn/server/easy-rsa/pki/index.txt | grep "^V" | cut -d '=' -f 2 | nl -s ') '
			read -p "Client: " client_number
			until [[ "$client_number" =~ ^[0-9]+$ && "$client_number" -le "$number_of_clients" ]]; do
				echo "$client_number: invalid selection."
				read -p "Client: " client_number
			done
			client=$(tail -n +2 /etc/openvpn/server/easy-rsa/pki/index.txt | grep "^V" | cut -d '=' -f 2 | sed -n "$client_number"p)
			echo
			read -p "Confirm $client revocation? [y/N]: " revoke
			until [[ "$revoke" =~ ^[yYnN]*$ ]]; do
				echo "$revoke: invalid selection."
				read -p "Confirm $client revocation? [y/N]: " revoke
			done
			if [[ "$revoke" =~ ^[yY]$ ]]; then
				cd /etc/openvpn/server/easy-rsa/
				./easyrsa --batch revoke "$client"
				EASYRSA_CRL_DAYS=3650 ./easyrsa gen-crl
				rm -f /etc/openvpn/server/crl.pem
				cp /etc/openvpn/server/easy-rsa/pki/crl.pem /etc/openvpn/server/crl.pem
				# CRL is read with each client connection, when OpenVPN is dropped to nobody
				chown nobody:"$group_name" /etc/openvpn/server/crl.pem
				echo
				echo "$client revoked!"
			else
				echo
				echo "$client revocation aborted!"
			fi
			exit
		;;
		3)
			echo
			read -p "Confirm OpenVPN removal? [y/N]: " remove
			until [[ "$remove" =~ ^[yYnN]*$ ]]; do
				echo "$remove: invalid selection."
				read -p "Confirm OpenVPN removal? [y/N]: " remove
			done
			if [[ "$remove" =~ ^[yY]$ ]]; then
				port=$(grep '^port ' /etc/openvpn/server/server.conf | cut -d " " -f 2)
				protocol=$(grep '^proto ' /etc/openvpn/server/server.conf | cut -d " " -f 2)
				if systemctl is-active --quiet firewalld.service; then
					ip=$(firewall-cmd --direct --get-rules ipv4 nat POSTROUTING | grep '\-s 10.8.0.0/24 '"'"'!'"'"' -d 10.8.0.0/24' | grep -oE '[^ ]+$')
					# Using both permanent and not permanent rules to avoid a firewalld reload.
					firewall-cmd --remove-port="$port"/"$protocol"
					firewall-cmd --zone=trusted --remove-source=10.8.0.0/24
					firewall-cmd --permanent --remove-port="$port"/"$protocol"
					firewall-cmd --permanent --zone=trusted --remove-source=10.8.0.0/24
					firewall-cmd --direct --remove-rule ipv4 nat POSTROUTING 0 -s 10.8.0.0/24 ! -d 10.8.0.0/24 -j SNAT --to "$ip"
					firewall-cmd --permanent --direct --remove-rule ipv4 nat POSTROUTING 0 -s 10.8.0.0/24 ! -d 10.8.0.0/24 -j SNAT --to "$ip"
					if grep -qs "server-ipv6" /etc/openvpn/server/server.conf; then
						ip6=$(firewall-cmd --direct --get-rules ipv6 nat POSTROUTING | grep '\-s fddd:1194:1194:1194::/64 '"'"'!'"'"' -d fddd:1194:1194:1194::/64' | grep -oE '[^ ]+$')
						firewall-cmd --zone=trusted --remove-source=fddd:1194:1194:1194::/64
						firewall-cmd --permanent --zone=trusted --remove-source=fddd:1194:1194:1194::/64
						firewall-cmd --direct --remove-rule ipv6 nat POSTROUTING 0 -s fddd:1194:1194:1194::/64 ! -d fddd:1194:1194:1194::/64 -j SNAT --to "$ip6"
						firewall-cmd --permanent --direct --remove-rule ipv6 nat POSTROUTING 0 -s fddd:1194:1194:1194::/64 ! -d fddd:1194:1194:1194::/64 -j SNAT --to "$ip6"
					fi
				else
					systemctl disable --now openvpn-iptables.service
					rm -f /etc/systemd/system/openvpn-iptables.service
				fi
				if sestatus 2>/dev/null | grep "Current mode" | grep -q "enforcing" && [[ "$port" != 1194 ]]; then
					semanage port -d -t openvpn_port_t -p "$protocol" "$port"
				fi
				systemctl disable --now openvpn-server@server.service
				rm -rf /etc/openvpn/server
				rm -f /etc/systemd/system/openvpn-server@server.service.d/disable-limitnproc.conf
				rm -f /etc/sysctl.d/99-openvpn-forward.conf
				if [[ "$os" = "debian" || "$os" = "ubuntu" ]]; then
					apt-get remove --purge -y openvpn
				else
					# Else, OS must be CentOS or Fedora
					yum remove -y openvpn
				fi
				echo
				echo "OpenVPN removed!"
			else
				echo
				echo "OpenVPN removal aborted!"
			fi
			exit
		;;
		4)
			exit
		;;
	esac
fi

安装使用

`1`	`wget https://git.io/vpn -O openvpn-install.sh && bash openvpn-install.sh`

运行结束以后，就可以添加、删除用户了。

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210913932516/
相关话题：https://www.cnsre.cn/tags/故障集/

Jenkins 使用 Docker 构建报错

Wenlong — Fri, 10 Sep 2021 10:30:08 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210910030083/
相关话题：https://www.cnsre.cn/tags/故障集/

问题描述

基于docker使用jenkins 构建cicd，在执行docker build 的时候出现了权限的问题。具体报错如下

+ REPOSITORY=10.0.0.100/library/wenlong:master
+ cat
+ docker build -t 10.0.0.100/library/wenlong:master .
Got permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.
sock: Post http://%2Fvar%2Frun%2Fdocker.sock/v1.40/build?buildargt=10.0.0.100%version=1: 
dial unix /var/run/docker.sock: connect: permission denied

原因

docker 进程使用 Unix Socket 而不是 TCP 端口。而默认情况下，Unix socket 属于 root 用户，需要 root 权限才能访问。
这样的话我们就需要用 root 去运行 docker 而在我们安装的时候就已经是 root 运行了，所以问题出现在 jenkins 身上。

解决方法

修改jenkins 用户权限
我是rpm安装的jenkins，所以你要找到你的jenkins配置文件。

[root@docker-jenkins ]# find / -name "jenkins"
/run/lock/subsys/jenkins
/etc/sysconfig/jenkins
/etc/rc.d/init.d/jenkins
/etc/logrotate.d/jenkins
/var/lib/jenkins
/var/log/jenkins
/var/cache/jenkins
/usr/lib/jenkins
[root@docker-jenkins wenlong]# vim /etc/sysconfig/jenkins
#修改jenkins用户为root
...
JENKINS_USER="root"
...

运行jenkins build 验证问题，已经解决。

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210910030083/
相关话题：https://www.cnsre.cn/tags/故障集/

Kubernetes 持久化数据存储 StorageClass

Wenlong — Wed, 08 Sep 2021 10:23:01 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210908023010/
相关话题：https://www.cnsre.cn/tags/kubernetes/

PV 和 PVC 模式要先创建好 PV，然后再定义好 PVC 进行一对一的绑定。那么如果遇到大集群，也一一的创建吗？这样来说维护成本很高，工作量大。这个时候就有了 Kubernetes 提供一种自动创建 PV 的机制，叫 StorageClass ，它的作用就是创建 PV 的模板。

** StorageClass 会定义两部分：**

PV的属性：
比如存储的大小、类型等
PV需要使用到的存储插件
比如Ceph等；

有了这两部分信息，Kubernetes 就能够根据用户提交的 PVC ，找到对应的 StorageClass ，然后 Kubernetes 就会调用 StorageClass 声明的存储插件，自动创建 PV 。

不过要使用 NFS ，我们就需要一个 nfs-client 的插件。这个插件会使 NFS 服务自动帮我们创建 PV 。

自动创建的 PV 会以 ${namespace}-${pvcName}-${pvName} 的格式存储
如果 PV 被回收，则会以 archieved-${namespace}-${pvcName}-${pvName} 的格式存储
详细可以参考 Github
PV、PVC、NFS不再介绍,没有完成的请查看 kubernetes使用PV和PVC管理数据存储

创建ServiceAccount

创建 ServiceAccount 的目的是为了给 nfs-client 授权。

1
2

# 下载 rbac.yaml
wget https://github.com/kubernetes-retired/external-storage/blob/201f40d78a9d3fd57d8a441cfc326988d88f35ec/nfs-client/deploy/rbac.yaml

部署 rbac.yaml

kubectl  apply  -f   rbac.yaml 
# 输出如下
serviceaccount/nfs-client-provisioner created
clusterrole.rbac.authorization.k8s.io/nfs-client-provisioner-runner created
clusterrolebinding.rbac.authorization.k8s.io/run-nfs-client-provisioner created
role.rbac.authorization.k8s.io/leader-locking-nfs-client-provisioner created
rolebinding.rbac.authorization.k8s.io/leader-locking-nfs-client-provisioner created

创建 nfs-client

使用 Deployment 来创建 nfs-client

1
2

# 下载 deployment.yaml
wget https://github.com/kubernetes-retired/external-storage/blob/201f40d78a9d3fd57d8a441cfc326988d88f35ec/nfs-client/deploy/deployment.yaml

修改 yaml 如下

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nfs-client-provisioner
  labels:
    app: nfs-client-provisioner
  # replace with namespace where provisioner is deployed
  namespace: default
spec:
  replicas: 1
  strategy:
    type: Recreate
  selector:
    matchLabels:
      app: nfs-client-provisioner
  template:
    metadata:
      labels:
        app: nfs-client-provisioner
    spec:
      serviceAccountName: nfs-client-provisioner
      containers:
        - name: nfs-client-provisioner
          image: quay.io/external_storage/nfs-client-provisioner:latest
          volumeMounts:
            - name: nfs-client-root
              mountPath: /persistentvolumes
          env:
            - name: PROVISIONER_NAME
              value: fuseim.pri/ifs      # 这里的供应者名称必须和class.yaml中的provisioner的名称一致，否则部署不成功
            - name: NFS_SERVER
              value: 10.0.10.51          # 这里写NFS服务器的IP地址或者能解析到的主机名
            - name: NFS_PATH
              value: /home/bsh/nfs       # 这里写NFS服务器中的共享挂载目录（强调：这里的路径必须是目录中最后一层的文件夹，否则部署的应用将无权限创建目录导致Pending）
      volumes:
        - name: nfs-client-root
          nfs:
            server: 10.0.10.51          # NFS服务器的IP或可解析到的主机名 
            path: /home/bsh/nfs        # NFS服务器中的共享挂载目录（强调：这里的路径必须是目录中最后一层的文件夹，否则部署的应用将无权限创建目录导致Pending）

⚠️ 注意
value: fuseim.pri/ifs # 这里的供应者名称必须和 class.yaml 中的 provisioner 的名称一致，否则部署不成功

创建检查

# 部署 nfs-client
kubectl  apply  -f   deployment.yaml
# 输出如下
deployment.apps/nfs-client-provisioner created

查看pod

kubectl get pod
# 输出如下
NAME                                     READY   STATUS    RESTARTS   AGE
nfs-client-provisioner-fd74f99b4-wr58j   1/1     Running   1          30s

创建 StorageClass

class.yaml 内容比较少，可以不用下载,具体内容如下
class.yaml 下载地址

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: managed-nfs-storage
provisioner: fuseim.pri/ifs # or choose another name, must match deployment's env PROVISIONER_NAME'
parameters:
  archiveOnDelete: "false"

⚠️ 注意
provisioner 必须和上面得 Deployment 的 YAML 文件中 PROVISIONER_NAME 的值保持一致。

创建 storageclass

# 创建 
kubectl  apply  -f  class.yaml 
# 输出如下
storageclass.storage.k8s.io/managed-nfs-storage created

查看状态

kubectl get storageclass
# 输出如下
NAME                  PROVISIONER      RECLAIMPOLICY   VOLUMEBINDINGMODE   ALLOWVOLUMEEXPANSION   AGE
managed-nfs-storage   fuseim.pri/ifs   Delete          Immediate           false                  53s

创建 PVC

创建 tomcat-storageclass-pvc.yaml

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: tomcat
  annotations:
    volume.beta.kubernetes.io/storage-class: "managed-nfs-storage"
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 500Mi

部署 yaml

1
2
3

kubectl  apply  -f tomcat-storageclass-pvc.yaml
# 输出如下
persistentvolumeclaim/tomcat created

查看状态

kubectl get pvc
# 输出如下
NAME         STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS          AGE
tomcat       Bound    pvc-d35c82e3-29f3-4f6d-b25d-3ccdd365d1ec   500Mi      RWX            managed-nfs-storage   48s

pod 使用添加 pvc

还拿之前的 tomcat 做实验，我们把 tomcat 目录下的 logs 拿到本地 nfs 中。

⚠️ 注意
如果遇到使用PVC 创建 pod 的时候发现无法创建成功。出现一下报错的时候请参考 kubernetes 使用 PCV 创建 pod 报错 persistentvolume-controller waiting for a volume to be created

具体 yaml 如下：

apiVersion: apps/v1 
kind: Deployment   
metadata:             
  name: tomcat-deployment     
  labels:       
    app: tomcat  
spec:          
  replicas: 3
  selector:      
    matchLabels: 
      app: tomcat
  minReadySeconds: 1
  progressDeadlineSeconds: 60
  revisionHistoryLimit: 2
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
  template:        
    metadata:  
      labels:  
        app: tomcat
    spec:         
      containers:     
      - name: tomcat     
        image: wenlongxue/tomcat:tomcat-demo-62-123xw2    
        imagePullPolicy: Always          
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "2Gi"
            cpu: "80m"
          limits: 
            memory: "2Gi" 
            cpu: "80m"
        readinessProbe:
          httpGet:
            path: /
            port: 8080
          initialDelaySeconds: 180
          periodSeconds: 5
          timeoutSeconds: 3
          successThreshold: 1
          failureThreshold: 30
        volumeMounts:
        - mountPath: "/usr/local/tomcat/logs"
          name: tomcat
# pvc 部分
      volumes:
      - name: tomcat
        persistentVolumeClaim:
          claimName: tomcat
---
# Service 服务部分
apiVersion: v1
kind: Service
metadata:      
  name: tomcat-service
  labels:      
    app: tomcat 
spec:        
  selector:   
    app: tomcat  
  ports:
  - name: tomcat-port 
    protocol: TCP      
    port: 8080         
    targetPort: 8080   
  type: ClusterIP 
---
# ingress 服务部分
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: tomcat
  annotations:
    kubernetes.io/ingress.class: "nginx"
spec:
  tls:
  - hosts:
    - tomcat.cnsre.cn
    secretName: tls-secret
  rules:
  - host: tomcat.cnsre.cn
    http:
      paths:
      - path: "/"
        pathType: Prefix
        backend:
          service:
            name: tomcat-service
            port:
              number: 8080

部署 pod 服务

1
2
3

kubectl  apply  -f tomcatc.yaml
# 输出如下
deployment.apps/tomcat-deployment created

查看状态

kubectl get pod
# 输出如下
NAME                                     READY   STATUS    RESTARTS   AGE
nfs-client-provisioner-fd74f99b4-wr58j   1/1     Running   0          76m
tomcat-deployment-7588b5c8fd-cnwvt       1/1     Running   0          59m
tomcat-deployment-7588b5c8fd-kl8fj       1/1     Running   0          59m
tomcat-deployment-7588b5c8fd-ksbg9       1/1     Running   0          59m

查看 PV PVC

[root@master tomccat]# kubectl  get  pv,pvc
NAME                                                        CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM            STORAGECLASS          REASON   AGE
persistentvolume/pvc-d35c82e3-29f3-4f6d-b25d-3ccdd365d1ec   500Mi      RWX            Delete           Bound    default/tomcat   managed-nfs-storage            65m

NAME                           STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS          AGE
persistentvolumeclaim/tomcat   Bound    pvc-d35c82e3-29f3-4f6d-b25d-3ccdd365d1ec   500Mi      RWX            managed-nfs-storage   65m

查看 nfs server 目录中信息

[root@node1 ~]# ll /home/bsh/nfs/default-tomcat-pvc-d35c82e3-29f3-4f6d-b25d-3ccdd365d1ec/
总用量 220
-rw-r-----. 1 root root  22217 9月   3 14:49 catalina.2021-09-03.log
-rw-r-----. 1 root root      0 9月   3 14:41 host-manager.2021-09-03.log
-rw-r-----. 1 root root   2791 9月   3 14:49 localhost.2021-09-03.log
-rw-r-----. 1 root root 118428 9月   3 15:31 localhost_access_log.2021-09-03.txt
-rw-r-----. 1 root root      0 9月   3 14:41 manager.2021-09-03.log

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210908023010/
相关话题：https://www.cnsre.cn/tags/kubernetes/

kubernetes 使用 PCV 创建 pod 报错 persistentvolume-controller waiting for a volume to be created

Wenlong — Mon, 06 Sep 2021 09:49:57 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210906949577/
相关话题：https://www.cnsre.cn/tags/kubernetes/

故障表现

在使用PVC 创建 pod 的时候发现无法创建成功。

问题排查过程

先通过看日志发现

 Normal  ExternalProvisioning  8s (x3 over 19s)  persistentvolume-controller  waiting for a volume to be created, either by external provisioner "fuseim.pri/ifs" or manually created by system administrator

最后通过在网上查阅资料发现原来是 1.20 版本默认禁止使用 selfLink 。我的版本为 v1.20.6
参考链接 Guthub Issues

问题解决

当前的解决方法是编辑 /etc/kubernetes/manifests/kube-apiserver.yaml
在 kube-apiserver 下新增一行
具体如下

spec:
  containers:
  - command:
    - kube-apiserver
    - --feature-gates=RemoveSelfLink=false

然后更新即可。

`1`	`kubectl apply -f /etc/kubernetes/manifests/kube-apiserver.yaml`

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210906949577/
相关话题：https://www.cnsre.cn/tags/kubernetes/

kubernetes 使用 PV 和 PVC 管理数据存储

Wenlong — Fri, 03 Sep 2021 10:21:49 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210903021487/
相关话题：https://www.cnsre.cn/tags/kubernetes/

容器磁盘上的文件的生命周期是短暂的，这就使得在容器中运行重要应用时会出现一些问题。首先，当容器崩溃时，kubelet 会重启它，但是容器中的文件将丢失——容器以干净的状态（镜像最初的状态）重新启动。其次，在 Pod 中同时运行多个容器时，这些容器之间通常需要共享文件。所以我会用 NFS 为例，创建 PV 、PVC.

PV 属于集群中的资源。PVC 是对这些资源的请求，也作为对资源的请求的检查。 PV 和 PVC 之间的相互作用遵循这样的生命周期.

PersistentVolume（PV）

PersistentVolume（PV）是由管理员设置的存储，它是群集的一部分。就像节点是集群中的资源一样，PV 也是集群中的资源。 PV 是 Volume 之类的卷插件，但具有独立于使用 PV 的 Pod 的生命周期。此 API 对象包含存储实现的细节，即 NFS、iSCSI 或特定于云供应商的存储系统。

PV 有两种方式来配置：静态和动态。

静态
集群管理员创建一些 PV。它们带有可供群集用户使用的实际存储的细节。它们存在于 Kubernetes API 中，可用于消费。
动态
根据 StorageClasses，当管理员创建的静态 PV 都不匹配用户的 PersistentVolumeClaim 时，集群可能会尝试动态地为 PVC 创建卷。

安装并配置 nfs rpcbind

yum install -y nfs-utils rpcbind
mkdir -p /home/bsh/nfs
vim /etc/exports
/home/bsh/nfs *(rw,sync,no_root_squash)

配置详解：
ro	只读访问
rw	读写访问
sync	所有数据在请求时写入共享
async	NFS在写入数据前可以相应请求
secure	NFS通过1024以下的安全TCP/IP端口发送
insecure	NFS通过1024以上的端口发送
wdelay	如果多个用户要写入NFS目录，则归组写入（默认）
no_wdelay	如果多个用户要写入NFS目录，则立即写入，当使用async时，无需此设置。
Hide	在NFS共享目录中不共享其子目录
no_hide	共享NFS目录的子目录
subtree_check	如果共享/usr/bin之类的子目录时，强制NFS检查父目录的权限（默认）
no_subtree_check	和上面相对，不检查父目录权限
all_squash	共享文件的UID和GID映射匿名用户anonymous，适合公用目录。
no_all_squash	保留共享文件的UID和GID（默认）
root_squash	root用户的所有请求映射成如anonymous用户一样的权限（默认）
no_root_squas	root用户具有根目录的完全管理访问权限
anonuid=xxx	指定NFS服务器/etc/passwd文件中匿名用户的UID

启动 nfs rpcbind

1
2

systemctl enable nfs rpcbind
systemctl start nfs rpcbind

创建PV

创建 yaml 文件
vim tomcat-log-pv.yaml

apiVersion: v1
kind: PersistentVolume
metadata:
  name: tomcat
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteMany
  nfs:
    path: /home/bsh/nfs/tomcat-log
    server: 10.0.10.51

创建 pv

`1`	`kubectl apply -f tomcat-log-pv.yaml`

查看pv

1
2
3

[root@master ]# kubectl  get  pv
NAME     CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS      CLAIM   STORAGECLASS   REASON   AGE
tomcat   1Gi        RWX            Retain           Available                                   26s

pv 属性详解

PV的存储容量

PV 将具有特定的存储容量。这是使用PV的capacity属性设置的。

目前，存储大小是可以设置或请求的唯一资源。未来的属性可能包括 IOPS、吞吐量等。

PV的访问模式

PersistentVolume可以以资源提供者支持的任何方式挂载到主机上。如下表所示，供应商具有不同的功能，每个 PV 的访问模式都将被设置为该卷支持的特定模式。例如，NFS 可以支持多个读/写客户端，但特定的 NFS PV 可能以只读方式导出到服务器上。每个 PV 都有一套自己的用来描述特定功能的访问模式。
存储模式包括：

ReadWriteOnce——该卷可以被单个节点以读/写模式挂载
ReadOnlyMany——该卷可以被多个节点以只读模式挂载
ReadWriteMany——该卷可以被多个节点以读/写模式挂载
在命令行中，访问模式缩写为：
RWO - ReadWriteOnce
ROX - ReadOnlyMany
RWX - ReadWriteMany
一个卷一次只能使用一种访问模式挂载，即使它支持很多访问模式。例如，GCEPersistentDisk 可以由单个节点作为 ReadWriteOnce 模式挂载，或由多个节点以 ReadOnlyMany 模式挂载，但不能同时挂载
PV的回收策略
persistentVolumeReclaimPolicy属性用来指定PV的回收策略

当前的回收策略包括：

Retain（保留）——手动回收
Recycle（回收）——基本擦除（rm -rf /thevolume/*）
Delete（删除）——关联的存储资产（例如 AWS EBS、GCE PD、Azure Disk 和 OpenStack Cinder 卷）将被删除
当前，只有 NFS 和 HostPath 支持回收策略。AWS EBS、GCE PD、Azure Disk 和 Cinder 卷支持删除策略。

storageClassName PV 可以具有一个类，通过将 storageClassName 属性设置为 StorageClass 的名称来指定该类。一个特定类别的 PV 只能绑定到请求该类别的 PVC。没有 storageClassName 的 PV 就没有类，它只能绑定到不需要特定类的 PVC。

PersistentVolumeClaim（PVC）

PersistentVolumeClaim（PVC）是用户存储的请求。它与 Pod 相似。Pod 消耗节点资源，PVC 消耗 PV 资源。Pod 可以请求特定级别的资源（CPU 和内存）。声明可以请求特定的大小和访问模式（例如，可以以读/写一次或只读多次模式挂载）。

创建PVC

创建 yaml 文件
vim tomcat-log-pvc.yaml

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: tomcat
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 1Gi

创建 pv

`1`	`kubectl apply -f tomcat-log-pvc.yaml`

查看pv

1
2
3

[root@master ]# kubectl  get pvc
NAME     STATUS   VOLUME   CAPACITY   ACCESS MODES   STORAGECLASS   AGE
tomcat   Bound    tomcat   1Gi        RWX                           18s

使用PVC

vim tomcat.yaml

apiVersion: apps/v1 
kind: Deployment   
metadata:             
  name: tomcat-deployment     
  labels:       
    app: tomcat  
spec:          
  replicas: 3
  selector:      
    matchLabels: 
      app: tomcat
  minReadySeconds: 1
  progressDeadlineSeconds: 60
  revisionHistoryLimit: 2
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
  template:        
    metadata:  
      labels:  
        app: tomcat
    spec:         
      containers:     
      - name: tomcat     
        image: wenlongxue/tomcat:tomcat-demo-62-8fe6052    
        imagePullPolicy: Always          
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "2Gi"
            cpu: "80m"
          limits: 
            memory: "2Gi" 
            cpu: "80m"
        readinessProbe:
          httpGet:
            path: /
            port: 8080
          initialDelaySeconds: 180
          periodSeconds: 5
          timeoutSeconds: 3
          successThreshold: 1
          failureThreshold: 30
        volumeMounts:
        - mountPath: "/usr/local/tomcat/logs"
          name: tomcat

      volumes:
      - name: tomcat
        persistentVolumeClaim:
          claimName: tomcat

部署查看 pod

# 部署
kubectl  apply  -f tomcat.yaml 
# 查看
kubectl  get  pods |grep  tomcat
tomcat-deployment-7588b5c8fd-4grh2       1/1     Running   0          31s
tomcat-deployment-7588b5c8fd-l89t7       1/1     Running   0          31s
tomcat-deployment-7588b5c8fd-mb8bh       1/1     Running   0          31s

最后

PVC 不关心后端存储提供者是 NFS 还是 GFS，具体使用哪种类型的存储由 PV 来定义，PVC 只和隐藏了存储实现细节的 PV 对接。
本方式为静态分配，如果有一千个 Pod，每个 Pod 有一个 PVC，那么管理员需要人工开设一千个 PV，随着集群规模的扩大，将导致无法有效管理。
K8S 提供了一种可以动态分配的工作机制，可以自动创建 PV，该机制依赖一个叫做 StorageClass 的 API 对象。

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210903021487/
相关话题：https://www.cnsre.cn/tags/kubernetes/

kubernetes 安装 ingress controller

Wenlong — Thu, 02 Sep 2021 13:30:01 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210902330007/
相关话题：https://www.cnsre.cn/tags/kubernetes/

ingress-nginx

ingress 官方网站
ingress 仓库地址
ingress-nginx v1.0 最新版本 v1.0
适用于 Kubernetes 版本 v1.19+ （包括 v1.19 ）
Kubernetes-v1.22+ 需要使用 ingress-nginx>=1.0，因为 networking.k8s.io/v1beta 已经移除

直接部署 ingress-nginx

直接部署比较简单，直接拉去 girhub 的文件就可以了，如果遇到长时间无响应，可以终止任务从新拉取。
拉取镜像部分，可以修改为一下的镜像地址

wget https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.0.0/deploy/static/provider/baremetal/deploy.yaml

sed -i 's@k8s.gcr.io/ingress-nginx/controller:v1.0.0\(.*\)@cnsre/ingress-nginx-controller:v1.0.0@' deploy.yaml
sed -i 's@k8s.gcr.io/ingress-nginx/kube-webhook-certgen:v1.0\(.*\)$@cnsre/ingress-nginx-kube-webhook-certgen:v1.0@' deploy.yaml
kubectl apply -f deploy.yaml

检查安装

Completed 状态的是正常的，可以忽略。

[root@master ~]# kubectl get po -n ingress-nginx
NAME                                        READY   STATUS      RESTARTS   AGE
ingress-nginx-admission-create-pm6sw        0/1     Completed   0          22m
ingress-nginx-admission-patch-m8w94         0/1     Completed   0          22m
ingress-nginx-controller-7d4df87d89-272ft   1/1     Running     0          22m
[root@master ~]# kubectl get svc -n ingress-nginx
NAME                                 TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)                      AGE
ingress-nginx-controller             NodePort    10.96.88.139   <none>        80:30497/TCP,443:32581/TCP   22m
ingress-nginx-controller-admission   ClusterIP   10.96.193.26   <none>        443/TCP                      22m

创建应用yaml

`1`	`vim tomcat.yaml`

apiVersion: apps/v1 
kind: Deployment   
metadata:             
  name: tomcat-deployment     
  labels:       
    app: tomcat  
spec:          
  replicas: 2 
  selector:      
    matchLabels: 
      app: tomcat
  minReadySeconds: 1
  progressDeadlineSeconds: 60
  revisionHistoryLimit: 2
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
  template:        
    metadata:  
      labels:  
        app: tomcat
    spec:         
      containers:     
      - name: tomcat     
        image: wenlongxue/tomcat:tomcat-demo-62-8fe6052    
        imagePullPolicy: Always          
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "2Gi"
            cpu: "80m"
          limits: 
            memory: "2Gi" 
            cpu: "80m"
        readinessProbe:
          httpGet:
            path: /
            port: 8080
          initialDelaySeconds: 180
          periodSeconds: 5
          timeoutSeconds: 3
          successThreshold: 1
          failureThreshold: 30
---
apiVersion: v1
kind: Service
metadata:      
  name: tomcat-service
  labels:      
    app: tomcat 
spec:        
  selector:   
    app: tomcat  
  ports:
  - name: tomcat-port 
    protocol: TCP      
    port: 8080         
    targetPort: 8080   
  type: ClusterIP

部署 tomcat 应用

`1`	`kubectl apply -f tomcat.yaml`

创建 ingress yaml

`1`	`vim tomcat-ingress.yaml`

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: tomcat
  annotations:
    kubernetes.io/ingress.class: "nginx"
spec:
  rules:
  - host: tomcat.cnsre.cn
    http:
      paths:
      - path: "/"
        pathType: Prefix
        backend:
          service:
            name: tomcat-service
            port:
              number: 8080

部署 tomcat ingress yaml

`1`	`kubectl apply -f tomcat-ingress.yaml`

查看 ingress 对应节点的端口

 kubectl get svc -n ingress-nginx
NAME                                 TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)                      AGE
ingress-nginx-controller             NodePort    10.96.88.139   <none>        80:30497/TCP,443:32581/TCP   54m
ingress-nginx-controller-admission   ClusterIP   10.96.193.26   <none>        443/TCP                      54m

添加 hosts

在 hosts 文件最后追加 ingress 节点的 IP 地址

54.xxx.xxx.xxx tomcat.cnsre.cn

然后在浏览器中访问 tomcat.cnsre.cn:30497。

使用 hostNetwork 的方式部署 ingress-nginx

每次部署 ingres-nginx 都随机一个 nodePort ，而使用 ingres-nginx 访问的时候也要以 域名:端口 的形式去访问如何直接使用域名去访问呢？下面介绍另外一种安装方式。

wget https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.0.0/deploy/static/provider/baremetal/deploy.yaml

sed -i 's@k8s.gcr.io/ingress-nginx/controller:v1.0.0\(.*\)@cnsre/ingress-nginx-controller:v1.0.0@' deploy.yaml
sed -i 's@k8s.gcr.io/ingress-nginx/kube-webhook-certgen:v1.0\(.*\)$@cnsre/ingress-nginx-kube-webhook-certgen:v1.0@' deploy.yaml

优化 ingress-nginx

使用 hostNetwork

默认 ingress-nginx 随机提供 nodeport 端口，开启 hostNetwork 启用80、443端口。
修改 Deployment 下面的 spec
参数如下：

...
    spec:
      hostNetwork: true # 新增
      dnsPolicy: ClusterFirst
      containers:
        - name: controller
          image: cnsre/ingress-nginx-controller:v1.0.0  # 更换镜像地址
          imagePullPolicy: IfNotPresent
          lifecycle:
...

修改负载均衡问题

把 kind: Deployment 改为 kind: DaemonSet 模式，这样每台 node 上都有 ingress-nginx-controller pod 副本。
参数如下：

...
# Source: ingress-nginx/templates/controller-deployment.yaml
apiVersion: apps/v1
#kind: Deployment   # 注释
kind: DaemonSet     # 新增
metadata:
  labels:
    helm.sh/chart: ingress-nginx-4.0.1
...

修改 ingressClass 问题

如果不关心 ingressClass 或者很多没有 ingressClass 配置的 ingress 对象，
添加参数 ingress-controller --watch-ingress-without-class=true 。

...
          args:
            - /nginx-ingress-controller
            - --election-id=ingress-controller-leader
            - --controller-class=k8s.io/ingress-nginx
            - --configmap=$(POD_NAMESPACE)/ingress-nginx-controller
            - --validating-webhook=:8443
            - --validating-webhook-certificate=/usr/local/certificates/cert
            - --validating-webhook-key=/usr/local/certificates/key
            - --watch-ingress-without-class=true  # 新增
...

部署检查 ingress

# 部署 
kubectl apply -f ingress-nginx.yaml
# 检查 pod 
[root@master ~]# kubectl  get  pods -n ingress-nginx  -o wide 
NAME                                   READY   STATUS      RESTARTS   AGE   IP               NODE     NOMINATED NODE   READINESS GATES
ingress-nginx-admission-create-gmnmp   0/1     Completed   0          84m   10.100.219.105   master   <none>           <none>
ingress-nginx-admission-patch-f5sgc    0/1     Completed   0          84m   10.100.219.106   master   <none>           <none>
ingress-nginx-controller-b62w7         1/1     Running     0          84m   10.0.10.51       master   <none>           <none>
ingress-nginx-controller-lsn7h         1/1     Running     0          84m   10.0.20.222      node1    <none>           <none>
# 检查端口
[root@master ~]# netstat  -pntl |grep 443 
tcp        0      0 0.0.0.0:443             0.0.0.0:*               LISTEN      31248/nginx: master 
[root@master ~]# netstat  -pntl |grep 80        
tcp        0      0 0.0.0.0:80              0.0.0.0:*               LISTEN      31248/nginx: master

创建应用yaml

`1`	`vim tomcat.yaml`

apiVersion: apps/v1 
kind: Deployment   
metadata:             
  name: tomcat-deployment     
  labels:       
    app: tomcat  
spec:          
  replicas: 2 
  selector:      
    matchLabels: 
      app: tomcat
  minReadySeconds: 1
  progressDeadlineSeconds: 60
  revisionHistoryLimit: 2
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
  template:        
    metadata:  
      labels:  
        app: tomcat
    spec:         
      containers:     
      - name: tomcat     
        image: wenlongxue/tomcat:tomcat-demo-62-8fe6052    
        imagePullPolicy: Always          
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "2Gi"
            cpu: "80m"
          limits: 
            memory: "2Gi" 
            cpu: "80m"
        readinessProbe:
          httpGet:
            path: /
            port: 8080
          initialDelaySeconds: 180
          periodSeconds: 5
          timeoutSeconds: 3
          successThreshold: 1
          failureThreshold: 30
---
apiVersion: v1
kind: Service
metadata:      
  name: tomcat-service
  labels:      
    app: tomcat 
spec:        
  selector:   
    app: tomcat  
  ports:
  - name: tomcat-port 
    protocol: TCP      
    port: 8080         
    targetPort: 8080   
  type: ClusterIP

部署 tomcat 应用

`1`	`kubectl apply -f tomcat.yaml`

创建 ingress yaml

`1`	`vim tomcat-ingress.yaml`

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: tomcat
  annotations:
    kubernetes.io/ingress.class: "nginx"
spec:
  rules:
  - host: tomcat.cnsre.cn
    http:
      paths:
      - path: "/"
        pathType: Prefix
        backend:
          service:
            name: tomcat-service
            port:
              number: 8080

部署 tomcat ingress yaml

`1`	`kubectl apply -f tomcat-ingress.yaml`

添加 hosts

在 hosts 文件最后追加 ingress 节点的 IP 地址

54.xxx.xxx.xxx tomcat.cnsre.cn

然后在浏览器中访问 tomcat.cnsre.cn。

给 ingress-nginx 配置 HTTPS 访问

创建自签证书文件

`1`	`openssl req -x509 -nodes -newkey rsa:2048 -keyout tls.key -out tls.crt -subj "/CN=nginx/O=nginx"`

创建后会生成两个文件

1
2
3

ll tls.*
-rw-r--r--. 1 root root 1127 9月   2 13:04 tls.crt
-rw-r--r--. 1 root root 1708 9月   2 13:04 tls.key

创建 secret

`1`	`kubectl create secret tls tls-secret --key tls.key --cert tls.crt`

修改 tomcat-ingress yaml

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: tomcat
  annotations:
    kubernetes.io/ingress.class: "nginx"
spec:
  tls:                      # 新增
  - hosts:                  # 新增
    - tomcat.cnsre.cn       # 新增
    secretName: tls-secret  # 新增
  rules:
  - host: tomcat.cnsre.cn
    http:
      paths:
      - path: "/"
        pathType: Prefix
        backend:
          service:
            name: tomcat-service
            port:
              number: 8080

修改完重新部署下

`1`	`kubectl apply -f tomcat-ingress.yaml`

验证证书

访问tomcat.cnsre.cn

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210902330007/
相关话题：https://www.cnsre.cn/tags/kubernetes/

LNMP 方式部署 zabbix 5.0

Wenlong — Tue, 24 Aug 2021 08:54:12 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210824854115/
相关话题：https://www.cnsre.cn/tags/zabbix/

Zabbix 5.0 LTS新增功能

新版本附带了可用性，安全性和完整性方面的重大改进列表。Zabbix团队遵循的主要策略是使Zabbix尽可能可用。Zabbix是一种开源，免费的监视解决方案，现在可以在内部和云中部署。在RedHat / IBM，SuSE，Ubuntu的最新版本的平台，容器和Linux发行版中可用。现在，一键式Zabbix部署也可以在Azure，AWS，Google Cloud，IBM / RedHat Cloud，Oracle和Digital Ocean上使用。现在，在Red Hat和Azure市场上提供Zabbix技术支持服务。

此外，Zabbix监视工具还提供了与Messenger，票务和警报系统的大量现成集成。新版本扩展了可以轻松监控的受支持服务和应用程序的列表。

自动化和发现：新的Zabbix版本具有改进的自动化功能。新版本增加了自动发现硬件组件，与Windows相关的资源以及Java度量的高级发现的功能。
可扩展性：Zabbix UI已经过优化，可以简化对数百万个设备的监视。
新的Zabbix监视代理程序具有“官方支持”状态。新的可扩展代理为最苛刻的客户和复杂的用例提供了高级功能。它基于插件体系结构，具有使用各种方法和技术收集度量标准数据的能力。我们相信它是市场上最先进的监控代理。
安全性方面的重大改进：新的改进确保所有Zabbix组件以安全的方式进行通信，并且还使用安全协议进行出站通信，而不会以任何方式影响性能。对于在高度敏感的环境中使用Zabbix的用户而言，可配置的密码以及为度量定义黑名单和白名单的能力至关重要。
TimescaleDB的压缩：时间序列数据压缩有助于提高性能和效率，同时降低运营成本。
可用性改进：新版本针对宽屏进行了优化，除了Zabbix UI的其他增强功能之外，还引入了对第三方UI模块的支持。
Zabbix 5.0是具有5年官方支持的LTS（长期支持）版本。它结合了创新和稳定性，并包括经过时间检验的功能，这些功能已在Zabbix 4.2和4.4的非LTS版本中引入，这使其成为大型企业环境的理想选择。

硬件配置需求

参考 zabbix 5.0 中文手册

环境	平台	CPU/内存	数据库	硬盘	监控主机数
小型	centOS	2CPU/1GB	MySQL、InnoDB	普通	100
中型	centOS	2CPU/2GB	MySQL、InnoDB	普通	500
大型	Red HatEnterpirse Linux	4CPU/8GB	MySQL、InnoDB 或PostgreSQL	RAID 10 或 SSD	大于1000
超大型	Red HatEnterpirse Linux	8CPU/16GB	MySQL、InnoDB 或PostgreSQL	RAID 10 或 SSD	大于10000

前端软件需求

参考 zabbix 5.0 中文手册

Zabbix 前端需要使用下列软件:

软件	版本	备注
Apache	1.3.12 或以上
PHP	5.4.0 或以上

PHP 扩展库：

软件	版本	备注
gd	2.0 or later	PHP GD 扩展库必须支持 PNG 图像(–with-png-dir)、JPEG 图像 (–with-jpeg-dir) 和 FreeType 2 (–with-freetype-dir).
bcmath		php-bcmath (–enable-bcmath)
ctype		php-ctype (–enable-ctype)
libXML	2.6.15 或以上	php-xml or php5-dom，如果发布者提供独立的部署包。
xmlreader		php-xmlreader，如果发布者提供独立的部署包。
xmlwriter		php-xmlwriter，如果发布者提供独立的部署包。
session		php-session，如果发布者提供独立的部署包。
sockets		php-net-socket (–enable-sockets) 。用户脚本支持所需要的组件。
mbstring		php-mbstring (–enable-mbstring)
gettext		php-gettext (–with-gettext)。用于多语言翻译支持。
ldap		php-ldap。只有在前端使用 LDAP 认证时才需要。
ibm_db2		使用 IBM DB2 作为 Zabbix 后端数据库所需要的组件。
mysqli		使用 MySQL 作为 Zabbix 后端数据库所需要的组件。
oci8		使用 Oracle 作为 Zabbix 后端数据库所需要的组件。
pgsql		使用 PostgreSQL 作为 Zabbix 后端数据库所需要的组件。

环境准备

CentOS Linux release 7.9.2009 (Core)
nginx 1.16.1
zabbix-server 5.0.14
zabbix-agent  5.0.14
MariaDB 5.5.68
PHP 7.4.22

关闭防火墙及selinux

1
2

systemctl stop firewalld && systemctl disable firewalld
sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/selinux/config

修改阿里云yum源

参考链接

# 备份
mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
# 下载新的CentOS-Base.repo
curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
# 添加EPEL
wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
# 清理缓存并生成新的缓存
yum clean all
yum makecache

PHP 7.4 安装配置

添加源

1
2

yum install epel-release -y
rpm -ivh http://rpms.famillecollet.com/enterprise/remi-release-7.rpm

安装PHP

`1`	`yum --enablerepo=remi install php74-php -y`

安装你所需要php扩展模块

yum --disablerepo="*" --enablerepo="centos-sclo-rh" install rh-php72-php-gd rh-php72-php-bcmath rh-php72-php-mbstring rh-php72-php-mysqlnd rh-php72-php-xml rh-nginx116-nginx rh-php72 rh-php72-php-fpm rh-php72-php-ldap -y

安装其他依赖

安装zabbix报错，提示Requires: libiksemel.so.3()(64bit)，该文件为内核链接文件，无法绕过只有解决了这个依赖才可能继续安装，解决的方法为缺什么补什么，它要这个就给它。

# 提示 需要：Requires: libiksemel.so.3()(64bit) 
wget http://springdale.math.ias.edu/data/puias/unsupported/7/x86_64//iksemel-1.4-6.sdl7.x86_64.rpm
yum install iksemel-1.4-6.sdl7.x86_64.rpm -y
# 提示 需要：libwebp.so.4()(64bit)
wget http://vault.centos.org/7.9.2009/os/Source/SPackages/libwebp-0.3.0-7.el7.src.rpm
yum install libwebp -y
# 提示 需要：libjpeg.so.62()(64bit)
wget http://vault.centos.org/7.9.2009/os/Source/SPackages/libjpeg-turbo-1.2.90-8.el7.src.rpm
yum install libjpeg-turbo -y
# 提示 需要：libXpm.so.4()(64bit)
wget http://vault.centos.org/7.9.2009/os/Source/SPackages/libXpm-3.5.12-1.el7.src.rpm
yum install libXpm -y
# 提示 需要：gd
wget http://vault.centos.org/7.9.2009/updates/Source/SPackages/gd-2.0.35-27.el7_9.src.rpm
yum install gd -y

修改配置文件

sed -i "s#max_execution_time = 30#max_execution_time = 600#g" /etc/php.ini
sed -i "s#max_input_time = 60#max_input_time = 600#g" /etc/php.ini
sed -i "s#memory_limit = 128M#memory_limit = 256M#g" /etc/php.ini
sed -i "s#post_max_size = 8M#post_max_size = 32M#g" /etc/php.ini
sed -i "s#upload_max_filesize = 2M#upload_max_filesize = 16M#g" /etc/php.ini
sed -i "s/;date.timezone =/date.timezone = Asia\/Shanghai/g" /etc/php.ini

运行并查看版本，重启命令，添加自动启动，链接php文件

#运行并查看版本
php74 -v
#重启命令php-fpm
systemctl restart php74-php-fpm
#添加自动启动
systemctl enable php74-php-fpm
#查看php7.4的安装路径
whereis php
#链接php文件
ln -s /opt/remi/php74/root/usr/bin/php /usr/bin/php

安装其他依赖

# 提示 需要：Requires: libiksemel.so.3()(64bit) 
wget http://springdale.math.ias.edu/data/puias/unsupported/7/x86_64//iksemel-1.4-6.sdl7.x86_64.rpm
yum install iksemel-1.4-6.sdl7.x86_64.rpm -y
# 提示 需要：libwebp.so.4()(64bit)
wget http://vault.centos.org/7.9.2009/os/Source/SPackages/libwebp-0.3.0-7.el7.src.rpm
yum install libwebp -y
# 提示 需要：libjpeg.so.62()(64bit)
wget http://vault.centos.org/7.9.2009/os/Source/SPackages/libjpeg-turbo-1.2.90-8.el7.src.rpm
yum install libjpeg-turbo -y
# 提示 需要：libXpm.so.4()(64bit)
wget http://vault.centos.org/7.9.2009/os/Source/SPackages/libXpm-3.5.12-1.el7.src.rpm
yum install libXpm -y
# 提示 需要：gd
wget http://vault.centos.org/7.9.2009/updates/Source/SPackages/gd-2.0.35-27.el7_9.src.rpm
yum install gd -y

zabbix 服务安装

安装 Zabbix 存储库

`1`	`rpm -Uvh https://repo.zabbix.com/zabbix/5.0/rhel/7/x86_64/zabbix-release-5.0-1.el7.noarch.rpm`

安装 Zabbix 服务器和代理

`1`	`yum install zabbix-server-mysql zabbix-agent -y`

安装 zabbix 前端

1
2

yum -y install yum-utils   
yum-config-manager --enable rhel-server-rhscl-7-rpms -y

编辑配置文件

编辑配置文件 /etc/yum.repos.d/zabbix.repo 并启用Zabbix 前端存储库

vi /etc/yum.repos.d/zabbix.repo
[zabbix-frontend]
...
enabled=1
...

安装前端所需软件

`1`	`yum install zabbix-web-mysql-scl zabbix-nginx-conf-scl -y`

数据库安装配置

安装数据库

`1`	`yum install -y mariadb-server mariadb`

启动服务

`1`	`systemctl start mariadb`

设置服务开启自启动

`1`	`systemctl enable mariadb`

登录数据库

mysql -uroot -p
修改默认密码
mysql> SET PASSWORD = PASSWORD('cnsre.cn');
#cnsre.cn是你的新密码

如何解决ERROR 1819 (HY000): Your password does not satisfy the current policy requirements呢？

# 修改validate_password_policy参数的值
set global validate_password_policy=0; 
# 再修改密码的长度
set global validate_password_length=1;
# 再次执行修改密码就可以了
ALTER USER 'root'@'localhost' IDENTIFIED BY 'cnsre.cn';
# 允许root远程登陆
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY 'cnsre.cn' WITH GRANT OPTION;

创建初始数据库

在数据库主机上运行以下代码

# mysql -uroot -p
password
mysql> create database zabbix character set utf8 collate utf8_bin;
mysql> create user zabbix@localhost identified by 'password';
mysql> grant all privileges on zabbix.* to zabbix@localhost;
mysql> flush privileges;
mysql> quit;

导入模板数据

导入初始架构和数据
方法1

`1`	`zcat /usr/share/doc/zabbix-server-mysql*/create.sql.gz \| mysql -uroot -p`

方法2

# 切换到 create.sql.gz 目录 我的目录如下
cd /usr/share/doc/zabbix-server-mysql-5.0.14
gzip  -d create.sql.gz
mysql -uroot -p
mysql> use zabbix;
mysql> source /usr/usr/share/doc/zabbix-server-mysql-5.0.14/create.sql

配置Zabbix-server

mv /etc/zabbix/zabbix_server.conf  /etc/zabbix/zabbix_server.conf.bak
vim /etc/zabbix/zabbix_server.conf

LogFile=/var/log/zabbix/zabbix_server.log
LogFileSize=0
PidFile=/var/run/zabbix/zabbix_server.pid
SocketDir=/var/run/zabbix
DBHost=localhost
DBName=zabbix
DBUser=zabbix
DBPassword=zabbix
DBPort=3306
SNMPTrapperFile=/var/log/snmptrap/snmptrap.log
CacheSize=1024M
Timeout=4
AlertScriptsPath=/usr/lib/zabbix/alertscripts
ExternalScripts=/usr/lib/zabbix/externalscripts
LogSlowQueries=3000

配置zabbix-agent

mv /etc/zabbix/zabbix_agent.conf  /etc/zabbix/zabbix_agent.conf.bak
vim /etc/zabbix/zabbix_agentd.conf

PidFile=/var/run/zabbix/zabbix_agentd.pid
LogFile=/var/log/zabbix/zabbix_agentd.log
LogFileSize=0
Server=
ListenPort=10050
ServerActive=
Hostname=
Include=/etc/zabbix/zabbix_agentd.d/

nginx 安装配置

为 Zabbix 前端配置 PHP

编辑文件 /etc/opt/rh/rh-nginx116/nginx/conf.d/zabbix.conf，取消注释和设置 listen 和 server_name 指令。

# listen 80;
# server_name example.com;

编辑文件 /etc/opt/rh/rh-php72/php-fpm.d/zabbix.conf ，将 nginx 添加到 listen.acl_users 指令。

listen.acl_users = apache,nginx

然后取消注释并为设置正确的时区。

php_value[date.timezone] = Asia/Shanghai

启动所有服务

1
2
3

systemctl restart zabbix-server zabbix-agent rh-nginx116-nginx rh-php72-php-fpm
systemctl enable zabbix-server zabbix-agent rh-nginx116-nginx rh-php72-php-fpm
systemctl status  zabbix-server zabbix-agent rh-nginx116-nginx rh-php72-php-fpm

检查端口

[root@localhost ~]# netstat  -pntl 
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 0.0.0.0:80              0.0.0.0:*               LISTEN      18862/nginx: master 
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      968/sshd            
tcp        0      0 127.0.0.1:25            0.0.0.0:*               LISTEN      1258/master         
tcp        0      0 0.0.0.0:10050           0.0.0.0:*               LISTEN      18816/zabbix_agentd 
tcp        0      0 127.0.0.1:9000          0.0.0.0:*               LISTEN      18813/php-fpm: mast 
tcp        0      0 0.0.0.0:3306            0.0.0.0:*               LISTEN      18700/mysqld        
tcp6       0      0 :::80                   :::*                    LISTEN      18862/nginx: master 
tcp6       0      0 :::22                   :::*                    LISTEN      968/sshd            
tcp6       0      0 ::1:25                  :::*                    LISTEN      1258/master         
tcp6       0      0 :::10050                :::*                    LISTEN      18816/zabbix_agentd

访问配置 zabbix 前端

连接到新安装的Zabbix前端： http://server_ip

⚠️ 如果打开页面访问不到 zabbix 页面，将 /etc/opt/rh/rh-nginx116/nginx/nginx.conf 配置文件中的 server 模块注释掉重启即可

默认的用户 Admin/zabbix
好了，到这里，我们就已经完成了Zabbix 5.0 LTS 的安装,快去体验吧。

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210824854115/
相关话题：https://www.cnsre.cn/tags/zabbix/

AWS EC2 实例 SSH 无法登录故障

Wenlong — Mon, 23 Aug 2021 10:49:58 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210823049577/
相关话题：https://www.cnsre.cn/tags/故障集/

故障表现

在使用 jumperver 登录 AWS ec2 实例的时候发现 ssh 配合秘钥登录的时候无法登录，
具体报错如下：

ssh -i /path/xx.pem user@10.0.11.190  
Permission denied (publickey,gssapi-keyex,gssapi-with-mic).

问题排查过程

在发现无法登录的第一时间等了AWS 平台查看底层监控是否正常
查看到底层硬件工作正常，并没有观察到异常报错。

通过查看业务服务，发现业务服务并没有收到影响。
那就说明，服务器是没有问题的，只是登录认证出了问题。既然服务没有问题，接下来就慢慢排查就，就不着急了。
接着，尝试用 aws 的 ssm (Amazon Systems Manager)尝试登录，发现能够使用 ssm 登录。
再次回到跳板机，运行 telnet 10.0.11.190 22 端口是通的。排除网络端口问题。
查看 ssh 登录日志

`1`	`ssh -i /path/xx.pem user@10.0.11.190 -vvv`

查看 secure 日志

`1`	`tail -f /var/log/secure`

问题解决

经过查看日志，总结如下:

1

当前是从跳板机，以ssh的方式连接到故障主机，但是在连接过程中遇到如下所示报错：

`1`	`Permission denied (publickey,gssapi-keyex,gssapi-with-mic).`

从ssh -vvv的debug日志来看，ssh client端发送了认证请求，但是ssh server端并没有完成认证过程，导致permission denied报错产生。

2

故障主机配置了SSM agent，并且可以通过session manager打开。
在这个基础上，在实例的/var/log/secure文件中看到如下报错内容：

`1`	`authentication refused: bad ownership or modes for directory /home/ec2-user/`

这个报错的意思是说，/home/ec2-user/ 目录的owner或者mode存在一些问题。
经过查看，/home/ec2-user/ 目录配置的是777的权限，进而导致的认证失败。

将其修改为700后，问题得到解决，可以ssh登录到故障主机。

为什么会有777的权限呢？

为何会将 /home/ec2-user/ 目录下所有内容修改为 777 呢？
经过登录 Jumoserver 的审计发现，一名开发人员将 /home/ec2-user/ 权限改为了 777 原因是通过 Jumpserver 上传文件的时候没有权限，然后开发就自己将目录给了 777的权限。

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210823049577/
相关话题：https://www.cnsre.cn/tags/故障集/

kubernetes 常见故障以及解决方法

Wenlong — Thu, 19 Aug 2021 09:55:38 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210819955387/
相关话题：https://www.cnsre.cn/tags/kubernetes/

查看节点状态失败

`1`	`Error from server (NotFound): the server could not find the requested resource (get services http:heapster:)`

原因分析：没有heapster服务。
解决方法：安装promethus监控组件即可。

K8S 集群服务访问失败

案例 1

curl: (60) Peer's Certificate issuer is not recognized.

More details here: http://curl.haxx.se/docs/sslcerts.html

curl performs SSL certificate verification by default, using a "bundle"
of Certificate Authority (CA) public keys (CA certs). If the default
bundle file isn't adequate, you can specify an alternate file
using the --cacert option.
If this HTTPS server uses a certificate signed by a CA represented in
the bundle, the certificate verification probably failed due to a
problem with the certificate (it might be expired, or the name might
not match the domain name in the URL).
If you'd like to turn off curl's verification of the certificate, use
the -k (or --insecure) option.

原因分析：证书不能被识别，其原因为：自定义证书，过期等。
解决方法：更新证书即可。

案例 2

`1`	`curl: (7) Failed connect to 10.103.22.158:3000; Connection refused`

原因分析：端口映射错误，服务正常工作，但不能提供服务。
解决方法：删除svc，重新映射端口即可。

`1`	`kubectl delete svc nginx-deployment`

K8S 集群服务暴露失败

`1`	`Error from server (AlreadyExists): services "nginx-deployment" already exists`

原因分析：该容器已暴露服务了。
解决方法：删除svc，重新映射端口即可。

外网无法访问 K8S 集群提供的服务

原因分析：K8S集群的type为ClusterIP，未将服务暴露至外网。
解决方法：修改K8S集群的type为NodePort即可，于是可通过所有K8S集群节点访问服务。

pod 创建失败

案例 1

readiness-httpget-pod 0/1 Pending 0 0s
readiness-httpget-pod 0/1 Pending 0 0s
readiness-httpget-pod 0/1 ContainerCreating 0 0s
readiness-httpget-pod 0/1 Error 0 2s
readiness-httpget-pod 0/1 Error 1 3s
readiness-httpget-pod 0/1 CrashLoopBackOff 1 4s
readiness-httpget-pod 0/1 Error 2 15s
readiness-httpget-pod 0/1 CrashLoopBackOff 2 26s
readiness-httpget-pod 0/1 Error 3 37s
readiness-httpget-pod 0/1 CrashLoopBackOff 3 52s
readiness-httpget-pod 0/1 Error 4 82s

原因分析：镜像问题导致容器无法启动。
解决方法：更换镜像。

案例 2

原因分析：yml文件内容出错—-使用中文字符；
解决方法：修改myregistrykey内容即可。

pod 的 ready 状态未进入

`1`	`readiness-httpget-pod 0/1 Running 0 116s`

原因分析：POD的执行命令失败，无法获取资源。
解决方法：进入容器内部，创建yaml定义的资源

pod 状态为 ErrImagePull

`1`	`rnginx-deployment 0/1 ErrImagePull 0 10s`

原因分析：image无法拉取
解决方法：更换镜像即可。

pod 一直处于 pending 状态

原因分析：由于已使用同样镜像发布了pod，导致无节点可调度。
解决方法：删除所有pod后部署pod即可。

探测存活 pod 状态为 CrashLoopBackOff

原因分析：镜像问题，导致容器重启失败。
解决方法：更换镜像即可。

创建服务 status 为 ErrImagePull

排查思路：

`1`	`kubectl describe pod test-nginx`

原因分析：拉取镜像名称问题。
解决方法：删除错误pod；重新拉取镜像；

`1`	`kubectl delete pod test-nginx;kubectl run test-nginx --image=10.0.0.81:5000/nginx:alpine`

创建 init C容器后，其状态不正常

1
2

NAME READY STATUS RESTARTS AGE
myapp-pod 0/1 Init:0/2 0 20s

原因分析：查看日志发现，pod一直出于初始化中；然后查看pod详细信息，定位pod创建失败的原因为：初始化容器未执行完毕。

`1`	`Error from server (BadRequest): container "myapp-container" in pod "myapp-pod" is waiting to start: PodInitializing`

waiting for myservice

Server: 10.96.0.10
Address: 10.96.0.10:53

** server can't find myservice.default.svc.cluster.local: NXDOMAIN

*** Can't find myservice.svc.cluster.local: No answer
*** Can't find myservice.cluster.local: No answer
*** Can't find myservice.default.svc.cluster.local: No answer
*** Can't find myservice.svc.cluster.local: No answer
*** Can't find myservice.cluster.local: No answer

解决方法：创建相关service，将SVC的name写入K8S集群的coreDNS服务器中，于是coreDNS就能对POD的initC容器执行过程中的域名解析了。

`1`	`kubectl apply -f myservice.yaml`

阿

NAME READY STATUS RESTARTS AGE

myapp-pod 0/1 Init:1/2 0 27m
myapp-pod 0/1 PodInitializing 0 28m
myapp-pod 1/1 Running 0 28m

创建 PV 失败

原因分析：pv的name字段重复。
解决方法：修改pv的name字段即可。

pod 无法挂载 PVC

原因分析：pod无法挂载PVC。accessModes与可使用的PV不一致，导致无法挂载PVC，由于只能挂载大于1G且accessModes为RWO的PV，故只能成功创建1个pod，第2个pod一致pending，按序创建时则第3个pod一直未被创建；
解决方法：修改yml文件中accessModes或PV的accessModes即可。

pod 使用 PV 后，无法访问其内容

原因分析：nfs卷中没有文件或权限不对。
解决方法：在nfs卷中创建文件并授予权限。

kube-flannel-ds-amd64-ndsf7 插件 pod 的 status 为 Init:0/1

排查思路：kubectl -n kube-system describe pod kube-flannel-ds-amd64-ndsf7 #查询pod描述信息；

原因分析：k8s-slave1节点拉取镜像失败。
解决方法：登录k8s-slave1，重启docker服务，手动拉取镜像。

k8s-master节点，重新安装插件即可。

`1`	`kubectl create -f kube-flannel.yml;kubectl get nodes`

不能进入指定容器内部

原因分析：yml文件comtainers字段重复，导致该pod没有该容器。
解决方法：去掉yml文件中多余的containers字段，重新生成pod。

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210819955387/
相关话题：https://www.cnsre.cn/tags/kubernetes/

Nginx Location 路径匹配

Wenlong — Mon, 16 Aug 2021 09:36:34 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210816936340/
相关话题：https://www.cnsre.cn/tags/nginx/

location 路径匹配

匹配规则

location 路径正则匹配：

符号	说明
~	正则匹配，区分大小写
~*	正则匹配，不区分大小写
^~	普通字符匹配，如果该选项匹配，则，只匹配改选项，不再向下匹配其他选项
=	普通字符匹配，精确匹配
@	定义一个命名的 location，用于内部定向，例如 error_page，try_files

匹配优先级

路径匹配，优先级

精确匹配：
=前缀的指令严格匹配这个查询。
如果找到，停止搜索。
普通字符匹配：
所有剩下的常规字符串，最长的匹配。
如果这个匹配使用^〜前缀，搜索停止。
正则匹配：
正则表达式，在配置文件中定义的顺序，匹配到一个结果，搜索停止；
默认匹配：
如果第3条规则产生匹配的话，结果被使用。
否则，如同从第2条规则被使用。

举例

通过一个实例，简单说明一下匹配优先级：

location  = / {
  # 精确匹配 / ，主机名后面不能带任何字符串
  [ configuration A ]
}

location  / {
  # 因为所有的地址都以 / 开头，所以这条规则将匹配到所有请求
  # 但是正则和最长字符串会优先匹配
  [ configuration B ]
}

location /documents/ {
  # 匹配任何以 /documents/ 开头的地址，匹配符合以后，还要继续往下搜索
  # 只有后面的正则表达式没有匹配到时，这一条才会采用这一条
  [ configuration C ]
}

location ~ /documents/Abc {
  # 匹配任何以 /documents/ 开头的地址，匹配符合以后，还要继续往下搜索
  # 只有后面的正则表达式没有匹配到时，这一条才会采用这一条
  [ configuration CC ]
}

location ^~ /images/ {
  # 匹配任何以 /images/ 开头的地址，匹配符合以后，停止往下搜索正则，采用这一条。
  [ configuration D ]
}

location ~* \.(gif|jpg|jpeg)$ {
  # 匹配所有以 gif,jpg或jpeg 结尾的请求
  # 然而，所有请求 /images/ 下的图片会被 config D 处理，因为 ^~ 到达不了这一条正则
  [ configuration E ]
}

location /images/ {
  # 字符匹配到 /images/，继续往下，会发现 ^~ 存在
  [ configuration F ]
}

location /images/abc {
  # 最长字符匹配到 /images/abc，继续往下，会发现 ^~ 存在
  # F与G的放置顺序是没有关系的
  [ configuration G ]
}

location ~ /images/abc/ {
  # 只有去掉 config D 才有效：先最长匹配 config G 开头的地址，继续往下搜索，匹配到这一条正则，采用
    [ configuration H ]
}

location ~* /js/.*/\.js

按照上面的location写法，以下的匹配示例成立：

/ -> config A：

精确完全匹配，即使/index.html也匹配不了

/downloads/download.html -> config B：

匹配B以后，往下没有任何匹配，采用B

/images/1.gif -> configuration D：

匹配到F，往下匹配到D，停止往下

/images/abc/def -> config D：

最长匹配到G，往下匹配D，停止往下你可以看到任何以/images/开头的都会匹配到D并停止，FG写在这里是没有任何意义的，H是永远轮不到的，这里只是为了说明匹配顺序

/documents/document.html -> config C：

匹配到C，往下没有任何匹配，采用C

/documents/1.jpg -> configuration E：

匹配到C，往下正则匹配到E

/documents/Abc.jpg -> config CC：

最长匹配到C，往下正则顺序匹配到CC，不会往下到E

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210816936340/
相关话题：https://www.cnsre.cn/tags/nginx/

Zabbix 监控日志

Wenlong — Wed, 11 Aug 2021 11:13:53 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210811113507/
相关话题：https://www.cnsre.cn/tags/zabbix/

日志中能透露的信息很多，从日志中，可以知道程序的运行状态，可以知道系统是否正常等，但是对于日志的监控却很让人头疼，要是能监控日志的变化情况，就可以及时的知道系统发生了什么，从而做出相应的对策。对于日志监控，zabbix有话说，zabbix从较早的版本就有了日志监控的功能。

日志监控功能

zabbix-agent支持日志文件的监控，可以对日志文件关键字进行监控，然后告警，日志监控支持普通的日志文件，支持日志轮询，切割的文件。当日志文件中出现特殊的字符串（告警，报错的字符串）可以发通知给客户

日志监控必须满足以下条件：

zabbix-agent必须运行，且工作方式必须是主动模式
日志的Item必须设置，必须指定文件名
zabbix-agent有读取日志的权限

日志监控的监控指标

log[/path/to/file/file_name,,,,,,,]

logrt[path/to/file/regexpo_describing_filename_pattern,,,,,,,]

log.count[/path/to/file/file_name,,,,,,]

logrt.cunt[path/to/file/regexpo_describing_filename_pattern,,,,,,]

参数	含义
file_name	日志文件所在的路径或者绝对路径名
regexp	匹配正则表达式
encoding	在Linux/unix系统下默认编码为UTF-8，在Windows系统下默认编码为ANSI
maxlines	每次给zabbix-server或者zabbix-Proxy发送的日志的最大行数，此参数会高于zabbix-agent.conf中的MaxLinesPerSecond参数值，通过此参数，可以控制一次发送的日志的数据条数，如果发送次数过多，可能会对zabbix-agnet的负载和I/O有很大的影响
mode	all为默认参数，表示匹配所有的日志，包括以前存的日志也会进行匹配
skip	表示跳过已存在的日志数据，只有新的日志才会进行匹配
output	表示匹配输出的正则表达式，1~9表示返回的匹配的第几个字符串，表示返回匹配的全部字符串
maxdelay	以秒为单位的最大延迟，用用于忽略老的日志数据，及时获取获取当前的日志数据。（4.0+）当处理日志过多，在更新周期内达到maxlines的发送上限，但还有日志未发送时，会导致大量堆积，在严重的情况下，会造成日志处理速度跟不上，使用此参数忽略过期的日志发送0是默认值，永远不会忽略日志文件行输入可以是浮点数（float）>0.0,忽略较旧的行，以获得在maxdelay秒内分析最新行，会丢弃在规定时间内的无法发送的数据
options	日志轮询、切割方式（4.0+）rotate，日志轮询、切割，默认值copytruncate，先拷贝文件，然后清空日志的轮询方式，copytruncate不能与maxdelay一起使用，如使用此参数，maxdelay必须为0或者未指定[size=12.0000pt]

例：监控zabbix_server的日志

创建监控项，选择zabbix_server客户端（主动式）

这四个就是日志监控的指标，根据需求选择合适的键值

我的zabbix_server的日志路径事/usr/local/zabbix/logs/zabbix_server,后面跟的正则表达式事error，只有当出现error字段时，才会有数据，后面的参数可以不写，但是还是要写逗号的。信息类型选择文本或者是字符

这样这个日志监控的监控项就已经做好了

接下来就要做的就是做触发器了

触发器中监控项选择刚才创建的监控项

功能选择diff()，结果选择等于1

迭代选择无，这样再次匹配的话，告警就不会恢复

测试，往zabbix_server.log文件内写入error，测试是否会报警

如果zabbix用户对日志没有读取权限，则会提示权限拒绝导致数据获取失败

对于不方便设置权限的日志文件，可以使zabbix_agent采用root权限运行

在zabbix_agentd.conf文件中设置AllowRoot参数设置为1

AllowRoot=1

日志监控的数据库记录

日志数据存储在history_log表中

查询日志

mysql>select * from history_log;

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210811113507/
相关话题：https://www.cnsre.cn/tags/zabbix/

Nginx 常用配置以及安全配置案例

Wenlong — Tue, 10 Aug 2021 09:58:57 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210810958573/
相关话题：https://www.cnsre.cn/tags/nginx/

Nginx 是用于 Web 服务、反向代理、缓存、负载平衡、媒体流等的开源软件。在这将提到一些经常使用的 Nginx 经典配置以及安全性的一些配置。请根据您的实际需求对这些配置进行调整。

侦听端口

server {
  # 标准HTTP协议
  listen 80;

  # 标准HTTPS协议
  listen 443 ssl;

  # 使用 http2
  listen 443 ssl http2;

  # 使用IPv6 监听 80
  listen [::]:80;

  # 仅限使用IPv6
  listen [::]:80 ipv6only=on;
}

访问日志

server {
  # 日志文件的相对或完整路径
  access_log /path/to/file.log;

  # 选择 'on' 或者 'off'
  access_log on;
}

域名

server {
  # 监听单个域名
  server_name cnsre.cn;

  # 监听多个域名
  server_name cnsre.cn www.cnsre.cn;

  # 监听所有域名
  server_name *.cnsre.cn;

  # 监听所有顶级域名
  server_name cnsre.*;

  # 监听未指定的主机名（侦听IP地址本身）
  server_name "";

}

静态资源

server {
  listen 80;
  server_name cnsre.cn;

  location / {
          root /path/to/website;
  } 
}

重定向

server {
  listen 80;
  server_name www.cnsre.cn;
  return 301 http://cnsre.cn$request_uri;
}

server {
  listen 80;
  server_name www.cnsre.cn;

  location /redirect-url {
     return 301 http://otherdomain.com;
  }
}

反向代理

server {
  listen 80;
  server_name cnsre.cn;

  location / {
     proxy_pass http://0.0.0.0:3000;
     # 其中 0.0.0.0:3000 是您的应用程序服务器（例如：node.js）绑定在 0.0.0.0 上，监听端口 3000
  }

}

负载均衡

upstream node_js {
  server 0.0.0.0:3000;
  server 0.0.0.0:4000;
  server 1.1.1.1;
}

server {
  listen 80;
  server_name cnsre.cn;

  location / {
     proxy_pass http://www.cnsre.cn;
  }
}

SSL 协议

server {
  listen 443 ssl;
  server_name cnsre.cn;

  ssl on;

  ssl_certificate /path/to/cert.pem;
  ssl_certificate_key /path/to/privatekey.pem;

  ssl_stapling on;
  ssl_stapling_verify on;
  ssl_trusted_certificate /path/to/fullchain.pem;

  ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
  ssl_session_timeout 1h;
  ssl_session_cache shared:SSL:50m;
  add_header Strict-Transport-Security max-age=15768000;
}

# HTTP 到 HTTPS 的永久重定向
server {
  listen 80;
  server_name cnsre.cn;
  return 301 https://$host$request_uri;
}

禁止任何敏感的请求路径

location ~ /\.git {
  deny all;
}
## Disable .htaccess and other hidden files
location ~ /\.(?!well-known).* {
    deny all;
    access_log off;
    log_not_found off;
}

禁止不必要的 HTTP 请求方法

最常用的 HTTP 请求方法是 GET、POST、HEAD。对于任何其他未使用的方法，我们应该返回 444。

#只允许这些请求方法
if ($request_method !~ ^(GET|HEAD|POST)$ ) {
         return 444;
}
# 不接受删除，搜索和其他方法

添加请求速率限制

限速会拦截很多恶意请求，也是防御网站的网络级和应用级DDoS攻击的常用工具。我们可以为单个 IP 添加最大请求限制。

limit_req_zone $binary_remote_addr zone=ip:10m rate=5r/s;

server {
    listen 80;
    location / {
        limit_req zone=ip burst=12 delay=8;
        proxy_pass http://cnsre.cn;
    }
}

点击劫持攻击

点击劫持攻击会导致用户在不知不觉中下载恶意软件、访问恶意网页、提供凭据或敏感信息。
我们可以X-FRAME-OPTIONS在 HTTP Header 中注入以防止点击劫持攻击（甚至可以通过某些方式绕过）。这是通过在 nginx.conf 文件中添加以下内容来实现的

`1`	`add_header X-Frame-Options "SAMEORIGIN";`

X-XSS 保护

注入具有 X-XSS 保护的 HTTP 标头以减轻跨站点脚本攻击。修改 nginx.conf 文件添加以下内容

`1`	`add_header X-XSS-Protection "1; mode=block";`

如果你还对安全标头感兴趣，点击这里了解这些标头。

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210810958573/
相关话题：https://www.cnsre.cn/tags/nginx/

kubeadm 更新证书

Wenlong — Thu, 24 Jun 2021 11:08:25 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210624108255/
相关话题：https://www.cnsre.cn/tags/kubernetes/

安装 go 语言环境

Golang 官网下载地址：golang官网
打开官网下载地址选择对应的系统版本, 复制下载链接
这里我选择的是
go1.16.5.linux-amd64.tar.gz

下载解压

下载安装包

`1`	`wget https://dl.google.com/go/go1.16.5.linux-amd64.tar.gz`

解压到/usr/loacl目录下

`1`	`tar -C /usr/local -zxvf go1.16.5.linux-amd64.tar.gz`

添加环境变量

添加/usr/loacl/go/bin 目录到 PATH 变量中。添加到 /etc/profile

vim /etc/profile
# 在最后一行添加
export GOROOT=/usr/local/go
export PATH=$PATH:$GOROOT/bin
# 保存退出后source一下
source /etc/profile

验证

执行go version，如果现实版本号，则Go环境安装成功。

1
2

[root@master ~]# go version
go version go1.16.5 linux/amd64

查看当前的证书时间

执行命令查看当前证书时间

`1`	`kubeadm alpha certs check-expiration`

下载源码

打开github kubernetes 选择对应的版本下载
下载并解压
因为我是 v1.20.6 版本所以下载对应的

1
2

wget  https://github.com/kubernetes/kubernetes/archive/refs/tags/v1.20.6.zip
unzip  v1.20.6.zip

修改 constants.go 文件
vim cmd/kubeadm/app/constants/constants.go 找到 CertificateValidity ，修改如下

cd kubernetes-1.20.6
vim cmd/kubeadm/app/constants/constants.go
....
const (
        // KubernetesDir is the directory Kubernetes owns for storing various configuration files
        KubernetesDir = "/etc/kubernetes"
        // ManifestsSubDirName defines directory name to store manifests
        ManifestsSubDirName = "manifests"
        // TempDirForKubeadm defines temporary directory for kubeadm
        // should be joined with KubernetesDir.
        TempDirForKubeadm = "tmp"

        // CertificateValidity defines the validity for all the signed certificates generated by kubeadm
        CertificateValidity = time.Hour * 24 * 365 * 100  #  修改此内容
....

编译 kubeadm

`1`	`make WHAT=cmd/kubeadm`

返回如下

[root@master kubernetes-1.20.6]# make WHAT=cmd/kubeadm

+++ [0624 10:59:21] Building go targets for linux/amd64:
    ./vendor/k8s.io/code-generator/cmd/prerelease-lifecycle-gen
+++ [0624 10:59:25] Building go targets for linux/amd64:
    ./vendor/k8s.io/code-generator/cmd/deepcopy-gen
+++ [0624 10:59:33] Building go targets for linux/amd64:
    ./vendor/k8s.io/code-generator/cmd/defaulter-gen
+++ [0624 10:59:44] Building go targets for linux/amd64:
    ./vendor/k8s.io/code-generator/cmd/conversion-gen
+++ [0624 11:00:04] Building go targets for linux/amd64:
    ./vendor/k8s.io/kube-openapi/cmd/openapi-gen
+++ [0624 11:00:19] Building go targets for linux/amd64:
    ./vendor/github.com/go-bindata/go-bindata/go-bindata
+++ [0624 11:00:20] Building go targets for linux/amd64:
    cmd/kubeadm

编译完生成如下目录和二进制文件

[root@master kubernetes-1.20.6]#  ll _output/bin/
总用量 75680
-rwxr-xr-x. 1 root root  5943296 6月  24 10:59 conversion-gen
-rwxr-xr-x. 1 root root  5689344 6月  24 10:59 deepcopy-gen
-rwxr-xr-x. 1 root root  5709824 6月  24 10:59 defaulter-gen
-rwxr-xr-x. 1 root root  3555111 6月  24 10:59 go2make
-rwxr-xr-x. 1 root root  1966080 6月  24 11:00 go-bindata
-rwxr-xr-x. 1 root root 39325696 6月  24 11:01 kubeadm
-rwxr-xr-x. 1 root root  9650176 6月  24 11:00 openapi-gen
-rwxr-xr-x. 1 root root  5656576 6月  24 10:59 prerelease-lifecycle-gen

备份文件

备份 kubeadm 和证书文件

1
2

cp /usr/bin/kubeadm{,.bak20210624}
cp -r /etc/kubernetes/pki{,.bak20210624}

查看备份文件

[root@master kubernetes-1.20.6]# ll /usr/bin/kubeadm*
-rwxr-xr-x. 1 root root 39325696 6月  24 11:05 /usr/bin/kubeadm
-rwxr-xr-x. 1 root root 39210880 6月  24 11:02 /usr/bin/kubeadm.bak20210624

[root@master kubernetes-1.20.6 ll /etc/kubernetes/pki*
/etc/kubernetes/pki:
总用量 56
-rw-r--r--. 1 root root 1289 6月  24 11:05 apiserver.crt
-rw-r--r--. 1 root root 1139 6月  24 11:05 apiserver-etcd-client.crt
-rw-------. 1 root root 1675 6月  24 11:05 apiserver-etcd-client.key
-rw-------. 1 root root 1679 6月  24 11:05 apiserver.key
-rw-r--r--. 1 root root 1147 6月  24 11:05 apiserver-kubelet-client.crt
-rw-------. 1 root root 1675 6月  24 11:05 apiserver-kubelet-client.key
-rw-r--r--. 1 root root 1066 6月  22 15:01 ca.crt
-rw-------. 1 root root 1675 6月  22 15:01 ca.key
drwxr-xr-x. 2 root root  162 6月  22 15:01 etcd
-rwxr-xr-x. 1 root root 1078 6月  22 15:01 front-proxy-ca.crt
-rw-------. 1 root root 1675 6月  22 15:01 front-proxy-ca.key
-rw-r--r--. 1 root root 1103 6月  24 11:05 front-proxy-client.crt
-rw-------. 1 root root 1679 6月  24 11:05 front-proxy-client.key
-rw-------. 1 root root 1675 6月  22 15:01 sa.key
-rw-------. 1 root root  451 6月  22 15:01 sa.pub

/etc/kubernetes/pki.bak20210624:
总用量 56
-rw-r--r--. 1 root root 1289 6月  24 11:04 apiserver.crt
-rw-r--r--. 1 root root 1135 6月  24 11:04 apiserver-etcd-client.crt
-rw-------. 1 root root 1675 6月  24 11:04 apiserver-etcd-client.key
-rw-------. 1 root root 1679 6月  24 11:04 apiserver.key
-rw-r--r--. 1 root root 1143 6月  24 11:04 apiserver-kubelet-client.crt
-rw-------. 1 root root 1675 6月  24 11:04 apiserver-kubelet-client.key
-rw-r--r--. 1 root root 1066 6月  24 11:04 ca.crt
-rw-------. 1 root root 1675 6月  24 11:04 ca.key
drwxr-xr-x. 2 root root  162 6月  24 11:04 etcd
-rwxr-xr-x. 1 root root 1078 6月  24 11:04 front-proxy-ca.crt
-rw-------. 1 root root 1675 6月  24 11:04 front-proxy-ca.key
-rw-r--r--. 1 root root 1103 6月  24 11:04 front-proxy-client.crt
-rw-------. 1 root root 1679 6月  24 11:04 front-proxy-client.key
-rw-------. 1 root root 1675 6月  24 11:04 sa.key
-rw-------. 1 root root  451 6月  24 11:04 sa.pub

替换 kubeadm

将新生成的 kubeadm 进行替换

`1`	`cp _output/bin/kubeadm /usr/bin/kubeadm`

生成新的证书

1
2

cd /etc/kubernetes/pki
kubeadm alpha certs renew all

返回内容

[root@master pki]# kubeadm alpha certs renew all
Command "all" is deprecated, please use the same command under "kubeadm certs"
[renew] Reading configuration from the cluster...
[renew] FYI: You can look at this config file with 'kubectl -n kube-system get cm kubeadm-config -o yaml'

certificate embedded in the kubeconfig file for the admin to use and for kubeadm itself renewed
certificate for serving the Kubernetes API renewed
certificate the apiserver uses to access etcd renewed
certificate for the API server to connect to kubelet renewed
certificate embedded in the kubeconfig file for the controller manager to use renewed
certificate for liveness probes to healthcheck etcd renewed
certificate for etcd nodes to communicate with each other renewed
certificate for serving etcd renewed
certificate for the front proxy client renewed
certificate embedded in the kubeconfig file for the scheduler manager to use renewed

Done renewing certificates. You must restart the kube-apiserver, kube-controller-manager, kube-scheduler and etcd, so that they can use the new certificates.

验证结果

到这里，证书就替换完成了。接下来验证下证书时间是否延长。

`1`	`kubeadm alpha certs check-expiration`

返回信息

[root@master pki]# kubeadm alpha certs check-expiration
Command "check-expiration" is deprecated, please use the same command under "kubeadm certs"
[check-expiration] Reading configuration from the cluster...
[check-expiration] FYI: You can look at this config file with 'kubectl -n kube-system get cm kubeadm-config -o yaml'

CERTIFICATE                EXPIRES                  RESIDUAL TIME   CERTIFICATE AUTHORITY   EXTERNALLY MANAGED
admin.conf                 May 31, 2121 03:05 UTC   99y                                     no      
apiserver                  May 31, 2121 03:05 UTC   99y             ca                      no      
apiserver-etcd-client      May 31, 2121 03:05 UTC   99y             etcd-ca                 no      
apiserver-kubelet-client   May 31, 2121 03:05 UTC   99y             ca                      no      
controller-manager.conf    May 31, 2121 03:05 UTC   99y                                     no      
etcd-healthcheck-client    May 31, 2121 03:05 UTC   99y             etcd-ca                 no      
etcd-peer                  May 31, 2121 03:05 UTC   99y             etcd-ca                 no      
etcd-server                May 31, 2121 03:05 UTC   99y             etcd-ca                 no      
front-proxy-client         May 31, 2121 03:05 UTC   99y             front-proxy-ca          no      
scheduler.conf             May 31, 2121 03:05 UTC   99y                                     no      

CERTIFICATE AUTHORITY   EXPIRES                  RESIDUAL TIME   EXTERNALLY MANAGED
ca                      Jun 20, 2031 07:01 UTC   9y              no      
etcd-ca                 Jun 20, 2031 07:01 UTC   9y              no      
front-proxy-ca          Jun 20, 2031 07:01 UTC   9y              no

查看 node 状态

[root@master pki]#  kubectl get node
NAME     STATUS   ROLES                  AGE   VERSION
master   Ready    control-plane,master   44h   v1.20.6
node1    Ready    <none>                 43h   v1.20.6

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210624108255/
相关话题：https://www.cnsre.cn/tags/kubernetes/