18、搭建高效服务器环境：HAProxy、Docker与Puppet的协同应用

raspberrypi5

于 2025-11-28 15:28:42 发布

阅读量12

点赞数

CC 4.0 BY-SA版权

分类专栏： Puppet实战：自动化运维精粹文章标签： HAProxy Docker Puppet

本文链接：https://blog.youkuaiyun.com/raspberrypi5/article/details/155474339

Puppet实战：自动化运维精粹专栏收录该内容

22 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

搭建高效服务器环境：HAProxy、Docker与Puppet的协同应用

1. 使用HAProxy对多个Web服务器进行负载均衡

负载均衡器用于在多个服务器之间分配负载。硬件负载均衡器价格较高，而软件负载均衡器可以实现硬件解决方案的大部分优势。HAProxy是大多数人选择的软件负载均衡器，它速度快、功能强大且高度可配置。

1.1 操作步骤

创建主配置文件 ：创建文件 modules/haproxy/manifests/master.pp ，内容如下：

class haproxy::master ($app = 'myapp') {
  # The HAProxy master server
  # will collect haproxy::slave resources and add to its balancer
  package { 'haproxy': ensure => installed }
  service { 'haproxy':
    ensure  => running,
    enable  => true,
    require => Package['haproxy'],
  }
  include haproxy::config
  concat::fragment { 'haproxy.cfg header':
    target  => 'haproxy.cfg',
    source  => 'puppet:///modules/haproxy/haproxy.cfg',
    order   => '001',
    require => Package['haproxy'],
    notify  => Service['haproxy'],
  }
  # pull in the exported entries
  Concat::Fragment <<| tag == "$app" |>> {
    target => 'haproxy.cfg',
    notify => Service['haproxy'],
  }
}

创建HAProxy配置文件 ：创建文件 modules/haproxy/files/haproxy.cfg ，内容如下：

global
        daemon
        user haproxy
        group haproxy
        pidfile /var/run/haproxy.pid
defaults
        log     global
        stats   enable
        mode    http
        option  httplog
        option  dontlognull
        option  dontlog-normal
        retries 3
        option  redispatch
        timeout connect 4000
        timeout client 60000
        timeout server 30000
listen  stats :8080
        mode http
        stats uri /
        stats auth haproxy:topsecret
listen  myapp 0.0.0.0:80
        balance leastconn

修改节点配置文件 ：修改 manifests/nodes.pp 文件如下：

node 'cookbook' {
  include haproxy
}

创建从服务器配置 ：在 haproxy::slave 类中创建从服务器配置：

class haproxy::slave ($app = "myapp", $localport = 8000) {
  # haproxy slave, export haproxy.cfg fragment
  # configure simple web server on different port
  @@concat::fragment { "haproxy.cfg $::fqdn":
    content => "\t\tserver ${::hostname} ${::ipaddress}:${localport}   check maxconn 100\n",
    order   => '0010',
    tag     => "$app",
  }
  include myfw
  firewall {"${localport} Allow HTTP to haproxy::slave":
    proto  => 'tcp',
    port   => $localport,
    action => 'accept',
  }
  class {'apache': }
  apache::vhost { 'haproxy.example.com':
    port          => '8000',
    docroot => '/var/www/haproxy',
  }
  file {'/var/www/haproxy':
    ensure  => 'directory',
    mode    => 0755,
    require => Class['apache'],
  }
  file {'/var/www/haproxy/index.html':
    mode    => '0644',
    content => "<html><body><h1>${::fqdn} haproxy::slave\n</body></html>\n",
    require => File['/var/www/haproxy'],
  }
}

创建拼接容器资源 ：在 haproxy::config 类中创建拼接容器资源：

class haproxy::config {
  concat {'haproxy.cfg':
    path  => '/etc/haproxy/haproxy.cfg',
    order => 'numeric',
    mode  => '0644',
  }
}

修改站点配置文件 ：修改 site.pp 以定义主节点和从节点：

node master {
  class {'haproxy::master':
    app => 'cookbook'
  }
}
node slave1,slave2 {
  class {'haproxy::slave':
    app => 'cookbook'
  }
}

在从服务器上运行Puppet ：

root@slave1:~# puppet agent -t

在主节点上运行Puppet ：

[root@master ~]# puppet agent -t

检查HAProxy统计信息界面 ：在Web浏览器中访问主节点的8080端口（ http://master.example.com:8080 ），确保一切正常（用户名和密码在 haproxy.cfg 中，分别为 haproxy 和 topsecret ）。也可以尝试访问代理服务，每次重新加载页面时，服务会从 slave1 重定向到 slave2 （ http://master.example.com ）。

1.2 工作原理

我们从前面各部分的不同组件构建了一个复杂的配置。这种类型的部署做得越多就越容易。从高层来看，我们配置主节点从从节点收集导出的资源。从节点导出其配置信息，以便HAProxy在负载均衡器中使用它们。当从节点添加到系统中时，它们可以导出其资源并自动添加到负载均衡器中。

我们使用 myfw 模块配置从节点和主节点上的防火墙，以允许通信。使用Forge Apache模块配置从节点上的监听Web服务器。我们能够用五行代码生成一个功能齐全的网站（再用十行代码将 index.html 放置在网站上）。

这里涉及到几件事，除了HAProxy配置外，还有防火墙配置和Apache配置。我们将重点关注导出的资源和HAProxy配置如何配合。

在 haproxy::config 类中，我们为HAProxy配置创建了拼接容器：

class haproxy::config {
  concat {'haproxy.cfg':
    path  => '/etc/haproxy/haproxy.cfg',
    order => 'numeric',
    mode  => 0644,
  }
}

在 haproxy::slave 中引用它：

class haproxy::slave ($app = "myapp", $localport = 8000) {
  # haproxy slave, export haproxy.cfg fragment
  # configure simple web server on different port
  @@concat::fragment { "haproxy.cfg $::fqdn":
    content => "\t\tserver ${::hostname} ${::ipaddress}:${localport}   check maxconn 100\n",
    order   => '0010',
    tag     => "$app",
  }

这里使用了一个小技巧，在导出的资源中不定义目标。如果定义了，从节点会尝试创建 /etc/haproxy/haproxy.cfg 文件，但从节点没有安装HAProxy，会导致目录失败。我们在 haproxy::master 中收集资源时修改资源：

# pull in the exported entries
Concat::Fragment <<| tag == "$app" |>> {
  target => 'haproxy.cfg',
  notify => Service['haproxy'],
}

除了在收集资源时添加目标外，我们还添加了一个通知，以便在配置中添加新主机时重新启动HAProxy服务。另一个重要的点是，我们将从节点配置的 order 属性设置为 0010 ，而在定义 haproxy.cfg 文件的头部时，使用 0001 的 order 值，以确保头部位于文件的开头：

concat::fragment { 'haproxy.cfg header':
  target  => 'haproxy.cfg',
  source  => 'puppet:///modules/haproxy/haproxy.cfg',
  order   => '001',
  require => Package['haproxy'],
  notify  => Service['haproxy'],
}

1.3 更多信息

HAProxy有大量的配置参数，你可以在 HAProxy官网探索。虽然HAProxy最常用于Web服务器，但它可以代理的不仅仅是HTTP。它可以处理任何类型的TCP流量，因此你可以使用它来平衡MySQL服务器、SMTP、视频服务器或任何你喜欢的负载。你可以使用这里展示的设计来解决多个服务器之间的许多服务协调问题。这种类型的交互非常常见，可以应用于许多负载均衡或分布式系统的配置。你可以使用前面描述的相同工作流程，让节点导出防火墙资源（ @@firewall ）以允许其自身访问。

2. 使用Puppet管理Docker

Docker是一个用于快速部署容器的平台。容器就像一个轻量级的虚拟机，可能只运行一个进程。Docker中的容器称为 docks ，并使用称为 Dockerfiles 的文件进行配置。Puppet可用于配置节点，不仅运行Docker，还可以配置和启动多个 docks 。然后，你可以使用Puppet确保你的 docks 正在运行并保持一致的配置。

2.1 准备工作

从Forge（ https://forge.puppetlabs.com/garethr/docker ）下载并安装Puppet Docker模块：

t@mylaptop ~ $ cd puppet
t@mylaptop ~/puppet $ puppet module install -i modules garethr-docker

将这些模块添加到你的Puppet仓库。 stahnma-epel 模块是基于Enterprise Linux的发行版所必需的，它包含企业Linux YUM仓库的额外软件包。

2.2 操作步骤

安装Docker并配置节点 ：在节点上安装Docker，我们只需要包含 docker 类。我们不仅要安装Docker，还要下载一个镜像并在测试节点上启动一个应用程序。在这个例子中，我们将创建一个名为 shipyard 的新机器。在 site.pp 中添加以下节点定义：

node shipyard {
  class {'docker': }
  docker::image {'phusion/baseimage': }
  docker::run {'cookbook':
    image   => 'phusion/baseimage',
    expose  => '8080',
    ports   => '8080',
    command => 'nc -k -l 8080',
  }
}

运行Puppet安装Docker ：在 shipyard 节点上运行Puppet以安装Docker，这也将下载 phusion/baseimage Docker镜像：

[root@shipyard ~]# puppet agent -t

验证容器是否运行 ：使用 docker ps 验证容器是否在 shipyard 上运行：

[root@shipyard ~]# docker ps

验证端口监听 ：通过连接到前面列出的端口（ 49157 ）验证 dock 是否在端口 8080 上运行 netcat ：

[root@shipyard ~]# nc -v localhost 49157

2.3 工作原理

我们首先从Forge安装了 docker 模块。这个模块在我们的节点上安装 docker - io 包以及任何必需的依赖项。然后定义了一个 docker::image 资源，这指示Puppet确保指定的镜像被下载并可供Docker使用。在第一次运行时，Puppet将使Docker下载镜像。我们使用 phusion/baseimage 作为示例，因为它非常小、知名，并且包含我们在示例中使用的 netcat 守护进程。有关 baseimage 的更多信息，请访问 http://phusion.github.io/baseimage-docker/ 。

接着定义了一个 docker::run 资源。这个例子不是非常有用，它只是在端口 8080 上以监听模式启动 netcat 。我们需要将该端口暴露给我们的机器，因此我们定义了 docker::run 资源的 expose 属性。 docker::run 资源还有许多其他选项，更多详细信息请参考源代码。

最后，我们使用 docker ps 列出 shipyard 机器上运行的 docks 。我们解析出本地机器上的监听端口并验证 netcat 是否正在监听。

2.4 更多信息

Docker是快速部署和开发的好工具。即使在最普通的硬件上，你也可以根据需要启动尽可能多的 docks 。Docker的一个很好的用途是让 docks 作为你的模块的测试节点。你可以创建一个包含Puppet的Docker镜像，然后在 dock 内运行Puppet。有关Docker的更多信息，请访问 http://www.docker.com/ 。

3. 创建自定义事实

虽然Facter的内置事实很有用，但实际上添加自己的事实非常容易。例如，如果你有位于不同数据中心或托管提供商的机器，你可以为此添加一个自定义事实，以便Puppet可以确定是否需要应用任何本地设置（例如，本地DNS服务器或网络路由）。

3.1 操作步骤

创建自定义事实文件 ：创建目录 modules/facts/lib/facter ，然后创建文件 modules/facts/lib/facter/hello.rb ，内容如下：

Facter.add(:hello) do
  setcode do
    "Hello, world"
  end
end

修改站点配置文件 ：修改 site.pp 文件如下：

node 'cookbook' {
  notify { $::hello: }
}

运行Puppet ：

[root@cookbook ~]# puppet agent -t

3.2 工作原理

Facter事实在与facter一起分发的Ruby文件中定义。Puppet可以通过在模块的 lib/facter 子目录中创建文件来向facter添加额外的事实。这些文件随后会被传输到客户端节点，就像我们之前看到的 puppetlabs - stdlib 模块一样。要让命令行facter使用这些Puppet事实，请在facter后面附加 -p 选项，如下所示：

[root@cookbook ~]# facter hello
[root@cookbook ~]# facter -p hello
Hello, world

如果你使用的是较旧版本的Puppet（早于3.0），你需要在 puppet.conf 文件中启用 pluginsync ，如下所示：

[main]
pluginsync = true

事实可以包含任何Ruby代码， setcode do ... end 块内计算的最后一个值将是事实返回的值。例如，你可以创建一个更有用的事实，返回当前登录到系统的用户数量：

Facter.add(:users) do
  setcode do
    %x{/usr/bin/who |wc -l}.chomp
  end
end

要在你的清单中引用该事实，只需像使用内置事实一样使用其名称：

notify { "${::users} users logged in": }

3.3 更多信息

保存事实定义的Ruby文件的名称无关紧要。你可以随意命名这个文件；事实的名称来自 Facter.add() 函数调用。你也可以在单个Ruby文件中多次调用此函数，以根据需要定义多个事实。例如，你可以grep /proc/meminfo 文件并返回几个基于内存信息的事实，如下所示：

File.open('/proc/meminfo') do |f|
  f.each_line { |line|
    if (line[/^Active:/])
      Facter.add(:memory_active) do
        setcode do line.split(':')[1].to_i
        end
      end
    end
    if (line[/^Inactive:/])
      Facter.add(:memory_inactive) do
        setcode do line.split(':')[1].to_i
        end
      end
    end
  }
end

将此文件同步到节点后， memory_active 和 memory_inactive 事实将如下可用：

[root@cookbook ~]# facter -p |grep memory_
memory_active => 63780
memory_inactive => 58188

你可以扩展事实的使用，以构建一个完全无节点的Puppet配置；换句话说，Puppet可以仅根据事实的结果决定将哪些资源应用于机器。Jordan Sissel在 http://www.semicomplete.com/blog/geekery/puppet-nodeless-configuration.html 中写过关于这种方法的文章。你可以在 Puppet Labs官网上了解更多关于自定义事实的信息，包括如何确保特定于操作系统的事实仅在相关系统上工作，以及如何对事实进行加权，以便按特定顺序对其进行评估。

4. 生成清单的工具与方法

4.1 使用 Puppet resource 命令生成清单

通过 Puppet resource 命令，我们可以根据系统上现有的资源状态自动生成 Puppet 清单。例如，要查看系统上的用户资源信息并生成对应的 Puppet 代码，可以使用以下命令：

puppet resource user

该命令会输出系统上所有用户的 Puppet 资源定义，示例输出如下：

user { 'root':
  ensure => 'present',
  uid    => '0',
  gid    => '0',
  home   => '/root',
  shell  => '/bin/bash',
}

你可以将这些输出复制到你的 Puppet 清单文件中，用于后续的配置管理。

4.2 使用其他工具生成清单

除了 Puppet resource 命令，还有其他工具可以帮助我们生成 Puppet 清单。例如，一些配置管理工具可以将现有的系统配置导出为 Puppet 清单格式。具体使用哪种工具取决于你的需求和系统环境。在选择工具时，需要考虑工具的兼容性、易用性和功能完整性。

4.3 操作步骤总结

使用 Puppet resource 命令 ：
1. 打开终端，进入需要操作的系统环境。
2. 输入 puppet resource <资源类型> 命令，其中 <资源类型> 可以是 user 、 package 、 service 等。
3. 将命令输出的 Puppet 代码复制到相应的清单文件中。
使用其他工具 ：
1. 选择适合你需求的工具，并进行安装和配置。
2. 根据工具的使用说明，将系统配置导出为 Puppet 清单格式。
3. 检查生成的清单文件，确保其符合你的配置要求。

5. 外部节点分类器的使用

外部节点分类器（External Node Classifier，ENC）是一种将 Puppet 与其他基础设施组件集成的方法。通过使用 ENC 脚本，我们可以根据节点的属性和环境信息动态地为节点分配类和参数。

5.1 操作步骤

创建 ENC 脚本 ：编写一个脚本，根据节点的信息返回该节点需要应用的类和参数。脚本可以使用任何编程语言编写，只要它能够输出符合 Puppet 要求的 JSON 或 YAML 格式的数据。以下是一个简单的 Python 示例：

import json

def get_node_info(node_name):
    # 根据节点名称返回节点的类和参数
    if node_name == 'node1':
        return {
            'classes': ['apache', 'mysql'],
            'parameters': {
                'apache_port': 80,
                'mysql_password': 'password123'
            }
        }
    else:
        return {
            'classes': ['nginx'],
            'parameters': {
                'nginx_port': 8080
            }
        }

node_name = 'node1'  # 这里可以根据实际情况获取节点名称
node_info = get_node_info(node_name)
print(json.dumps(node_info))

配置 Puppet 服务器 ：在 Puppet 服务器的配置文件中指定 ENC 脚本的路径。打开 puppet.conf 文件，添加以下内容：

[master]
node_terminus = exec
external_nodes = /path/to/your/enc/script.py

运行 Puppet 代理 ：在节点上运行 Puppet 代理，Puppet 会调用 ENC 脚本获取节点的配置信息，并应用相应的类和参数。

puppet agent -t

5.2 工作原理

当 Puppet 代理向 Puppet 服务器请求配置时，Puppet 服务器会调用 ENC 脚本。ENC 脚本根据节点的名称或其他属性查询相应的配置信息，并以 JSON 或 YAML 格式返回给 Puppet 服务器。Puppet 服务器根据返回的信息为节点生成相应的目录（catalog），然后将目录发送给 Puppet 代理进行应用。

5.3 更多信息

使用 ENC 可以实现更灵活的节点分类和配置管理。你可以根据不同的业务需求和环境条件，动态地为节点分配类和参数。同时，ENC 还可以与其他系统集成，如 LDAP、CMDB 等，实现更全面的配置管理。

6. 创建自定义资源类型和提供者

6.1 创建自定义资源类型

自定义资源类型允许我们扩展 Puppet 的功能，以管理特定的系统资源。以下是创建自定义资源类型的步骤：
1. 创建资源类型定义文件 ：在 modules/<模块名>/lib/puppet/type 目录下创建一个 Ruby 文件，定义资源类型。例如，创建一个名为 myresource.rb 的文件，内容如下：

Puppet::Type.newtype(:myresource) do
  @doc = "Manage my custom resource"

  newparam(:name, :namevar => true) do
    desc "The name of the resource"
  end

  newproperty(:ensure) do
    desc "Whether the resource should exist"
    newvalues(:present, :absent)
    defaultto :present
  end
end

使用自定义资源类型 ：在 Puppet 清单中使用自定义资源类型，示例如下：

myresource { 'example':
  ensure => 'present',
}

6.2 创建自定义提供者

自定义提供者负责实现自定义资源类型的具体操作。以下是创建自定义提供者的步骤：
1. 创建提供者定义文件 ：在 modules/<模块名>/lib/puppet/provider/<资源类型名> 目录下创建一个 Ruby 文件，定义提供者。例如，创建一个名为 myresource.rb 的文件，内容如下：

Puppet::Type.type(:myresource).provide(:default) do
  def create
    # 实现资源创建的操作
    puts "Creating resource #{resource[:name]}"
  end

  def destroy
    # 实现资源删除的操作
    puts "Destroying resource #{resource[:name]}"
  end

  def exists?
    # 检查资源是否存在的操作
    false
  end
end

运行 Puppet 应用配置 ：当 Puppet 应用包含自定义资源类型的清单时，会调用相应的提供者执行操作。

puppet agent -t

6.3 工作原理

Puppet 在处理自定义资源类型时，会根据资源的状态和属性调用相应的提供者方法。提供者方法负责与系统进行交互，实现资源的创建、删除、检查等操作。通过创建自定义资源类型和提供者，我们可以将特定的系统管理任务集成到 Puppet 的配置管理框架中。

6.4 更多信息

自定义资源类型和提供者可以让我们更好地管理复杂的系统资源。在创建自定义资源类型和提供者时，需要注意代码的可维护性和兼容性。同时，还可以参考 Puppet 官方文档和社区资源，获取更多关于自定义资源类型和提供者的开发经验和技巧。

7. 创建自定义函数

自定义函数可以扩展 Puppet 的功能，让我们在 Puppet 清单中实现更复杂的逻辑。以下是创建自定义函数的步骤：

7.1 操作步骤

创建函数定义文件 ：在 modules/<模块名>/lib/puppet/parser/functions 目录下创建一个 Ruby 文件，定义函数。例如，创建一个名为 myfunction.rb 的文件，内容如下：

module Puppet::Parser::Functions
  newfunction(:myfunction, :type => :rvalue) do |args|
    # 函数的实现逻辑
    input = args[0]
    return input.upcase
  end
end

在 Puppet 清单中使用自定义函数 ：在 Puppet 清单中调用自定义函数，示例如下：

$input = "hello"
$output = myfunction($input)
notify { $output: }

运行 Puppet 应用配置 ：执行 puppet agent -t 命令，Puppet 会调用自定义函数并输出结果。

7.2 工作原理

Puppet 在解析 Puppet 清单时，会识别自定义函数的调用，并调用相应的 Ruby 代码执行函数逻辑。函数的返回值会被用于后续的配置管理操作。通过创建自定义函数，我们可以在 Puppet 清单中实现数据处理、逻辑判断等复杂功能。

7.3 更多信息

自定义函数可以提高 Puppet 清单的灵活性和可维护性。在创建自定义函数时，需要注意函数的输入输出格式和错误处理。同时，还可以参考 Puppet 官方文档和社区资源，学习更多关于自定义函数的开发技巧和最佳实践。

8. 测试 Puppet 清单

8.1 使用 rspec - puppet 进行测试

rspec - puppet 是一个用于测试 Puppet 清单的工具。它可以帮助我们验证 Puppet 代码的正确性和可靠性。以下是使用 rspec - puppet 进行测试的步骤：
1. 安装 rspec - puppet ：使用以下命令安装 rspec - puppet：

gem install rspec - puppet

创建测试文件 ：在 spec/classes 目录下创建一个 Ruby 文件，编写测试用例。例如，创建一个名为 myclass_spec.rb 的文件，内容如下：

require 'spec_helper'

describe 'myclass' do
  it { should compile }
  it { should contain_package('example_package').with_ensure('installed') }
end

运行测试 ：在终端中运行以下命令执行测试：

rspec spec/classes/myclass_spec.rb

8.2 测试的重要性

通过测试 Puppet 清单，我们可以在部署之前发现代码中的错误和问题，避免在生产环境中出现配置错误。测试还可以帮助我们确保 Puppet 代码的质量和稳定性，提高配置管理的效率和可靠性。

8.3 操作步骤总结

安装 rspec - puppet ：使用 gem install rspec - puppet 命令进行安装。
编写测试用例 ：在 spec/classes 目录下创建测试文件，使用 rspec - puppet 的语法编写测试用例。
运行测试 ：使用 rspec <测试文件路径> 命令执行测试。

9. 模块管理工具

9.1 使用 librarian - puppet

librarian - puppet 是一个用于管理 Puppet 模块依赖的工具。它可以帮助我们自动下载和更新所需的 Puppet 模块。以下是使用 librarian - puppet 的步骤：
1. 安装 librarian - puppet ：使用以下命令安装 librarian - puppet：

gem install librarian - puppet

创建 Puppetfile ：在项目根目录下创建一个 Puppetfile 文件，指定所需的 Puppet 模块。示例如下：

mod 'puppetlabs - stdlib', '4.3.2'
mod 'garethr - docker', '3.3.0'

安装模块 ：在终端中运行以下命令安装模块：

librarian - puppet install

9.2 使用 r10k

r10k 是另一个用于管理 Puppet 模块的工具，它支持从 Git 仓库中拉取模块，并可以实现模块的版本控制。以下是使用 r10k 的步骤：
1. 安装 r10k ：使用以下命令安装 r10k：

gem install r10k

配置 r10k ：在 /etc/puppetlabs/puppet/r10k.yaml 文件中配置 r10k 的参数，指定模块的来源和存储路径。示例如下：

:sources:
  :myorg:
    remote: 'git@github.com:myorg/puppet - modules.git'
    basedir: '/etc/puppetlabs/code/environments'

同步模块 ：在终端中运行以下命令同步模块：

r10k deploy environment -p

9.3 模块管理的重要性

使用模块管理工具可以帮助我们更好地管理 Puppet 模块的依赖关系，提高代码的可维护性和复用性。同时，模块管理工具还可以实现模块的版本控制，确保在不同环境中使用一致的模块版本。

9.4 操作步骤对比

工具名称	安装命令	配置文件	操作命令
librarian - puppet	`gem install librarian - puppet`	`Puppetfile`	`librarian - puppet install`
r10k	`gem install r10k`	`/etc/puppetlabs/puppet/r10k.yaml`	`r10k deploy environment -p`