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

# 说明：发行版自带的 salt 包版本往往很旧，
#       官方推荐直接配 Salt 自己的软件源（saltproject.io）。

# RHEL / Rocky / Alma 9
sudo dnf install -y https://repo.saltproject.io/salt/py3/redhat/9/x86_64/latest/SALTSTACK-GPG-KEY.pub
curl -fsSL https://repo.saltproject.io/salt/py3/redhat/9/x86_64/latest.repo | sudo tee /etc/yum.repos.d/salt.repo
sudo dnf clean expire-cache
sudo dnf install -y salt-master salt-minion

# Debian / Ubuntu
sudo mkdir -p /etc/apt/keyrings
sudo curl -fsSL https://repo.saltproject.io/salt/py3/ubuntu/22.04/amd64/latest/SALTSTACK-GPG-KEY.pub \
  -o /etc/apt/keyrings/salt-archive-keyring.pgp
echo "deb [signed-by=/etc/apt/keyrings/salt-archive-keyring.pgp] https://repo.saltproject.io/salt/py3/ubuntu/22.04/amd64/latest jammy main" \
  | sudo tee /etc/apt/sources.list.d/salt.list
sudo apt update && sudo apt install -y salt-master salt-minion

# 启动服务（Master 上通常同时跑 master 和 minion，方便用 salt-call 在本地测试）
sudo systemctl enable --now salt-master
sudo systemctl enable --now salt-minion

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# /etc/salt/minion.d/master.conf
master: 192.168.1.100      # Master 地址（也可以写主机名）
id: web-server-1           # Minion ID：**一旦确定就别改**，改了等于换了一台新机器
master_port: 4505          # Master 的发布端口；返回端口 4506 在 Master 侧由 ret_port 定义

# 启动 Minion
sudo systemctl enable --now salt-minion

# 查看自己的 ID 和生成的公钥
sudo salt-call --local grains.get id
sudo cat /etc/salt/pki/minion/minion.pub

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

# /etc/salt/master.d/master.conf
interface: 0.0.0.0
publish_port: 4505
ret_port: 4506
worker_threads: 10
timeout: 10
file_roots:
  base:
    - /srv/salt
pillar_roots:
  base:
    - /srv/pillar

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

# 查看密钥状态：Unaccepted / Accepted / Denied
sudo salt-key -L

# 查看待接受密钥的指纹，人工核对后再接受（生产环境推荐）
sudo salt-key -f web-server-1
sudo salt-key -a web-server-1      # 接受单个

# 接受全部（方便，但等于"谁连上来都放行"，仅限测试环境）
sudo salt-key -A

# 测试 Minion 连通性
sudo salt '*' test.ping

# 执行命令
sudo salt 'web-*' cmd.run "uptime"

# 按 Grains / Pillar 定向（不靠主机名）
sudo salt -G 'os:Ubuntu' test.ping
sudo salt -I 'env:prod' test.ping

# 查看某台机器的完整信息
sudo salt 'web-1' grains.items
sudo salt 'web-1' pillar.items

# 安装包
sudo salt 'db-*' pkg.install nginx

# 复制文件
sudo salt 'web-*' cp.get_file salt://nginx/nginx.conf /etc/nginx/nginx.conf

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

# /srv/salt/nginx/init.sls
nginx_install:
  pkg.installed:
    - name: nginx

nginx_service:
  service.running:
    - name: nginx
    - enable: true
    - require:
      - pkg: nginx_install

nginx_config:
  file.managed:
    - name: /etc/nginx/nginx.conf
    - source: salt://nginx/nginx.conf
    - template: jinja
    - require:
      - pkg: nginx_install
    - watch_in:
      - service: nginx_service      # 配置文件变化时，自动重启服务

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# /srv/salt/top.sls
base:
  '*':
    - common             # 所有机器都应用 common
  'web-*':
    - match: glob
    - nginx
  'os:Ubuntu':
    - match: grain
    - ubuntu-extra

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

# 应用一个指定的 State（对应 /srv/salt/nginx/init.sls）
sudo salt '*' state.apply nginx

# 等价写法
sudo salt '*' state.sls nginx

# 应用全部 State：按 top.sls 的规则给每台机器收敛到目标状态
sudo salt '*' state.highstate

# 先空跑看会改什么（test=True 是全局试运行，强烈推荐）
sudo salt '*' state.apply nginx test=True
sudo salt '*' state.highstate test=True

# 查看 top.sls 最终给每台机器生成了什么
sudo salt '*' state.show_top
sudo salt '*' state.show_highstate

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# /srv/pillar/common.sls —— 这里只写"数据"，不写 Jinja 逻辑
mysql_root_password: "change-me-in-production"
app_version: 1.0.0

# /srv/pillar/top.sls —— 决定"哪台机器拿到哪些 pillar 文件"
base:
  '*':
    - common
  'db-*':
    - database

1
2
3
4
5
6
7
8
9

# 查看某台机器的全部 grains
sudo salt 'web-*' grains.items

# 只看关心的几项
sudo salt '*' grains.item os osrelease num_cpus

# 按 grains 定向执行（-G = 按 grains 匹配）
sudo salt -G 'os:Ubuntu' pkg.install nginx
sudo salt -G 'os_family:RedHat' cmd.run 'dnf -y update'

1
2
3
4
5

# 方式一：静态文件 /etc/salt/grains（简单直接）
roles:
  - webserver
  - api
environment: production

1
2
3
4
5
6

# 方式二：写在 State 里，让它随配置自动生成（推荐，可版本化）
# /srv/salt/grains/init.sls
grains_role:
  grains.present:
    - name: roles
    - value: [webserver, api]

1
2

# 写完后刷新一下（静态文件方式需要重启 minion 或执行 saltutil.sync_grains）
sudo salt '*' saltutil.sync_grains

1
2
3
4
5
6
7
8

# 一条命令在本地应用一个 State
salt-call --local state.apply nginx

# 本地 highstate
salt-call --local state.highstate

# 本地执行命令
salt-call --local cmd.run 'df -h'

1
2
3
4
5
6
7
8
9

# /etc/salt/minion.d/masterless.conf —— 让它彻底脱离 Master
master_type: disable
file_client: local
file_roots:
  base:
    - /srv/salt
pillar_roots:
  base:
    - /srv/pillar

1
2
3
4
5
6

# /etc/salt/master
reactor:
  - 'minion_start':            # 事件名（新的 Minion 上线时触发）
    - /srv/reactor/start.sls
  - 'salt/auth':               # 有 Minion 请求认证时触发（可自动签发或拒绝）
    - /srv/reactor/auth.sls

1
2
3
4
5
6
7

# /srv/reactor/start.sls
# 新机器一上线就自动应用基础配置
new_minion_bootstrap:
  local.state.apply:
    - tgt: {{ data['id'] }}
    - arg:
      - base_setup

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

# 列出所有 Minion 密钥（含未接受的）
sudo salt-run wheel.key.list_all

# 按匹配规则批量接受 / 拒绝
sudo salt-run wheel.key.accept match='web-*'
sudo salt-run wheel.key.reject match='bad-*'

# 查看 Master 生效的配置
sudo salt-run config.values

# 管理 job 缓存
sudo salt-run jobs.list_jobs
sudo salt-run jobs.active

1
2
3
4
5

# 在 Syndic 主机上：既要跑一个 Master 进程，又要跑 salt-syndic 连接上级
# /etc/salt/master（Syndic 主机）
syndic_master: 192.168.1.100
syndic_master_port: 4506
order_masters: True     # 允许上级 Master 通过本 Syndic 下发命令

1
2
3
4
5

# Syndic 主机上启用两个服务
sudo systemctl enable --now salt-master salt-syndic

# 在顶级 Master 上就能看到所有下级机器
sudo salt '*' test.ping

1
2
3
4
5
6

# /etc/salt/roster —— 主机清单（支持正则/分组）
web1:
  host: 192.168.1.101
  user: ubuntu
  sudo: True
  # priv: /path/to/id_ed25519  # 指定私钥

1
2
3
4
5
6
7
8
9

# 安装（salt-ssh 是独立的包）
sudo dnf install -y salt-ssh

# 先测连通性
sudo salt-ssh '*' test.ping

# 执行 State / 命令
sudo salt-ssh 'web*' state.apply nginx
sudo salt-ssh 'web*' cmd.run 'uptime'

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

# 说明：Puppet 7 已进入维护末期，新部署建议直接用 Puppet 8。
#       官方的 puppet7-release-el-7 仓库对应的是已经 EOL 的 CentOS 7，
#       新环境请选 el-8 / el-9 的仓库包。

# RHEL / Rocky / Alma 9：先装官方仓库
sudo dnf install -y https://yum.puppet.com/puppet8-release-el-9.noarch.rpm

# 在 Master（puppetserver 角色）上安装
sudo dnf install -y puppetserver
sudo systemctl enable --now puppetserver

# 在 Agent 上安装
sudo dnf install -y puppet-agent

# 检查服务与端口（Master 默认监听 8140）
systemctl status puppetserver --no-pager
sudo ss -lntp | grep 8140

1
2

# Agent 侧需要能解析并连通 Master（防火墙放行 8140/tcp）
sudo firewall-cmd --permanent --add-port=8140/tcp && sudo firewall-cmd --reload

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

# /etc/puppetlabs/puppet/puppet.conf
[main]
server = puppet.example.com
certname = web-server-1.example.com

[agent]
# 每 30 分钟自动拉取一次配置（1800 秒）；调试时可临时设成 60
runinterval = 1800

# 首次连接需要让 Master 签发证书（Agent 会先提交 CSR 等待批准）
sudo systemctl enable --now puppet
# 在 Master 上查看待签发列表并批准
# sudo puppetserver ca list --all
# sudo puppetserver ca sign --certname web-server-1.example.com

# 手动触发一次（首次跑会先完成证书交换，可能会失败一次，再跑一次即可）
sudo puppet agent --test

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

# 示例：安装 Nginx
# /etc/puppetlabs/code/environments/production/manifests/nginx.pp

class nginx {
  # 安装包
  package { 'nginx':
    ensure => installed,
  }

  # 配置文件
  file { '/etc/nginx/nginx.conf':
    ensure  => file,
    source  => 'puppet:///modules/nginx/nginx.conf',
    require => Package['nginx'],
  }

  # 服务
  service { 'nginx':
    ensure     => running,
    enable     => true,
    hasrestart => true,
    subscribe  => File['/etc/nginx/nginx.conf'],
  }
}

# 应用类
include nginx

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# 包资源
package { 'vim':
  ensure => installed,
}

# 文件资源
file { '/tmp/test.txt':
  content => "Hello Puppet\n",
  mode    => '0644',
  owner   => 'root',
}

# 服务资源
service { 'sshd':
  ensure     => running,
  enable     => true,
  hasrestart => true,
}

# 用户资源
user { 'deploy':
  ensure     => present,
  shell      => '/bin/bash',
  home       => '/home/deploy',
  managehome => true,
}

# cron 资源
cron { 'backup':
  command => '/scripts/backup.sh',
  hour    => 2,
  minute  => 0,
  ensure  => present,
}

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

# /etc/puppetlabs/code/environments/production/modules/mysql/manifests/init.pp
class mysql {
  package { 'mysql-server':
    ensure => installed,
  }

  service { 'mysqld':
    ensure => running,
    enable => true,
  }

  file { '/etc/my.cnf':
    source => 'puppet:///modules/mysql/my.cnf',
    notify => Service['mysqld'],
  }
}

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

# Hiera 数据（分层配置）
# /etc/puppetlabs/code/environments/production/hieradata/common.yaml
---
ntp::servers:
  - 0.pool.ntp.org
  - 1.pool.ntp.org

# /etc/puppetlabs/code/environments/production/hieradata/production.yaml
---
ntp::servers:
  - time1.example.com
  - time2.example.com

1
2
3
4
5
6
7
8
9

# /etc/puppetlabs/code/environments/production/hiera.yaml
version: 5
hierarchy:
  - name: "按节点"
    path: "nodes/%{trusted.certname}.yaml"
  - name: "按环境"
    path: "%{environment}.yaml"
  - name: "公共默认值"
    path: "common.yaml"

1
2
3
4
5
6
7
8
9

# 类定义：给参数设默认值（Hiera 会自动填充）
class ntp (
  Array[String] $servers = ['0.pool.ntp.org'],
) {
  # ...
}

# 使用：不用手工传参，Hiera 会按 ntp::servers 这个键自动查找
include ntp

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

# /etc/puppetlabs/puppet/puppet.conf（Master 的 [master] 段）
environmentpath = /etc/puppetlabs/code/environments
# 代码不在本机、从 Git 拉取时还会配置：
#   environment_timeout = 0        # 每次编译都重新读取代码（开发环境方便）
#   code = /etc/puppetlabs/code    # Puppet 8 新的代码目录声明

# 创建环境
mkdir -p /etc/puppetlabs/code/environments/production/{manifests,modules}
mkdir -p /etc/puppetlabs/code/environments/staging/{manifests,modules}

# 指定环境运行
puppet agent --test --environment staging

# 在 Master 上远程触发某台 Agent 立即拉取（不用等 runinterval）
sudo puppetserver ca list --all
sudo puppet kick web-server-1.example.com

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

# ⚠️ 老教程里的 "Chef DK（Development Kit）" 早已停止维护，
#    现在用的是 Chef Workstation（开发机）和 Chef Infra Client（被管理机）。

# 安装 Chef Workstation（Linux；macOS 也可以 brew install --cask chef-workstation）
curl -L https://omnitruck.chef.io/install.sh | sudo bash -s -- -P chef-workstation -c stable

# 被管理节点只需要客户端
# curl -L https://omnitruck.chef.io/install.sh | sudo bash -s -- -P chef -c stable

# ⚠️ Chef 从 15 起要求显式接受许可协议，否则命令直接拒绝执行
export CHEF_LICENSE=accept-no-persist     # 也可写进 /etc/chef/client.rb 的 license 配置
# 想确认版本与许可状态：
chef --version
chef-client --version

1
2
3
4
5
6

# 初始化 Chef 工作目录（生成一个标准的 chef-repo 骨架）
mkdir chef-repo && cd chef-repo
chef generate repo .

# 创建一个 cookbook
chef generate cookbook cookbooks/mycookbook

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

chef-repo/
├── cookbooks/
│   └── mycookbook/
│       ├── recipes/
│       │   └── default.rb      # 默认入口：一个 Recipe 就是一个 Ruby 文件
│       ├── attributes/
│       │   └── default.rb      # cookbook 的默认属性值
│       ├── templates/
│       │   └── nginx.conf.erb  # ERB 模板
│       ├── files/
│       │   └── default/        # 直接分发的静态文件
│       ├── test/               # 集成测试（InSpec）
│       └── metadata.rb         # 名称、版本、依赖
├── roles/
└── environments/

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

# recipes/default.rb

# 安装 Nginx
package 'nginx' do
  action :install
end

# 启动服务
service 'nginx' do
  action [:enable, :start]
end

# 复制配置
template '/etc/nginx/nginx.conf' do
  source 'nginx.conf.erb'
  owner 'root'
  group 'root'
  mode '0644'
  notifies :restart, 'service[nginx]'
end

# 创建网站目录
directory '/var/www/myapp' do
  owner 'www-data'
  group 'www-data'
  mode '0755'
  action :create
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

# package 资源
package 'vim' do
  action :install
end

# service 资源
service 'nginx' do
  action [:enable, :start]
end

# file 资源
file '/tmp/test.txt' do
  content 'Hello Chef!'
  mode '0644'
  owner 'root'
end

# directory 资源
directory '/opt/myapp' do
  owner 'app'
  group 'app'
  mode '0755'
  recursive true
end

# user 资源
user 'deploy' do
  shell '/bin/bash'
  home '/home/deploy'
  manage_home true
end

# cron 资源
cron 'backup' do
  hour '2'
  minute '0'
  command '/scripts/backup.sh'
end

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

# roles/webserver.rb
name 'webserver'
description 'Web Server Role'
run_list 'recipe[nginx]', 'recipe[myapp]'

default_attributes({
  'nginx' => {
    'port' => 80,
    'worker_processes' => 4
  }
})

override_attributes({
  'myapp' => {
    'environment' => 'production'
  }
})

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

# 本地模式（不需要 Server）：-z 就是 --local-mode 的简写
cd chef-repo
chef-client -z -r 'recipe[mycookbook]'

# 只跑指定 Recipe，并看详细输出
chef-client -z -r 'recipe[mycookbook::default]' --chef-license accept

# 演练：只报告将要做什么，不真正执行
chef-client -z -r 'recipe[mycookbook]' --why-run

# 有 Server 时：用 knife 上传 cookbook / 管理节点
knife cookbook upload mycookbook        # 上传到 Chef Infra Server
knife node list                         # 列出已注册节点
knife node run_list set web1 'recipe[mycookbook]'
knife role from file roles/webserver.rb

1
2

# 老写法（已不可用）：
# chef-solo -c /etc/chef/solo.rb

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 现代等价写法：本地模式 + 指定 cookbook 路径和节点属性文件
mkdir -p /etc/chef
cat > /etc/chef/client.rb << 'EOF'
cookbook_path '/srv/chef/cookbooks'
file_cache_path '/var/cache/chef'
node_path '/srv/chef/nodes'
Chef::Config[:license_acceptance] = true
EOF

chef-client -z -c /etc/chef/client.rb -j /etc/chef/node.json

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# macOS
brew install terraform

# Linux（推荐配官方软件源，方便升级；也可用 tfenv 管理版本）
wget -O - https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update && sudo apt install -y terraform

# 验证
terraform version

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

# main.tf

# 指定 Provider 与版本约束（版本一定要锁，否则某天 Provider 升级会把资源改成"要重建"）
terraform {
  required_version = ">= 1.5"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
  # 凭证不要写在这里：用环境变量、aws configure 或运行时角色
}

# 动态查询最新 AMI，避免写死会过期的 ami-xxxx
data "aws_ami" "al2023" {
  most_recent = true
  owners      = ["amazon"]

  filter {
    name   = "name"
    values = ["al2023-ami-*-x86_64"]
  }
}

# 创建资源
resource "aws_instance" "web" {
  ami           = data.aws_ami.al2023.id
  instance_type = "t3.micro"
  vpc_security_group_ids = [aws_security_group.web_sg.id]
  
  tags = {
    Name        = "web-server"
    Environment = "production"
  }
}

# 创建安全组
resource "aws_security_group" "web_sg" {
  name = "web-security-group"
  
  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  ingress {
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

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

# 初始化
terraform init

# 格式化代码
terraform fmt

# 验证配置
terraform validate

# 预览执行计划
terraform plan -out=tfplan

# 应用更改（执行刚刚审核过的那份计划）
terraform apply tfplan

# 交互确认模式（会先展示计划再问 yes/no）
terraform apply

# 查看当前状态
terraform show

# 列出资源
terraform state list

# 销毁资源
terraform destroy

# 输出
terraform output

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

# variables.tf
variable "instance_type" {
  description = "EC2 实例类型"
  type        = string
  default     = "t3.micro"
}

variable "environment" {
  description = "环境名称"
  type        = string
  default     = "production"
}

# 敏感变量：不写默认值，运行时用 TF_VAR_db_password 注入
variable "db_password" {
  description = "数据库密码"
  type        = string
  sensitive   = true
}

# outputs.tf
output "instance_ip" {
  description = "实例公网 IP"
  value       = aws_instance.web.public_ip
}

output "instance_id" {
  description = "实例 ID"
  value       = aws_instance.web.id
}

# 敏感输出会被日志打码，但依然存在于 state 里
output "db_connection" {
  description = "数据库连接串"
  value       = "postgres://app:${var.db_password}@db.example.com:5432/app"
  sensitive   = true
}

1
2
3
4
5
6
7

# modules/vpc/main.tf
module "vpc" {
  source = "./modules/vpc"
  
  cidr_block = "10.0.0.0/16"
  environment = var.environment
}

1
2
3
4
5

# 三个工具的"空跑"对照，改动前先预演一遍
sudo salt '*' state.highstate test=True          # Salt
sudo puppet agent --test --noop                  # Puppet
chef-client -z -r 'recipe[mycookbook]' --why-run # Chef
ansible-playbook site.yml --check --diff         # Ansible