厨师 – 快速指南
厨师 – 快速指南
厨师 – 概述
Chef 是由 Opscode 开发的开源技术。Opscode 的联合创始人 Adam Jacob 被称为 Chef 的创始人。该技术使用 Ruby 编码来开发基本构建块，如食谱和食谱。Chef 用于基础设施自动化，有助于减少基础设施管理的手动和重复性任务。
对于管理和自动化基础架构所需的不同构建块，Chef 有自己的约定。
为什么是厨师？
Chef 是一种配置管理技术，用于自动化基础设施供应。它是在 Ruby DSL 语言的基础上开发的。它用于简化配置和管理公司服务器的任务。它有能力与任何云技术集成。
在 DevOps 中，我们使用 Chef 在内部和云端部署和管理服务器和应用程序。
厨师的特点
以下是 Chef 最突出的特点 –
-
Chef 使用流行的 Ruby 语言来创建特定于领域的语言。
-
Chef 不会对节点的当前状态进行假设。它使用其机制来获取机器的当前状态。
-
Chef 非常适合部署和管理云服务器、存储和软件。
厨师的优势
厨师提供以下优势 –
-
较低的入门门槛– 由于 Chef 使用原生 Ruby 语言进行配置，这是一种标准配置语言，任何有一定开发经验的人都可以轻松掌握。
-
与云的出色集成– 使用刀具实用程序，它可以轻松地与任何云技术集成。对于希望在多云环境中分布其基础架构的组织来说，它是最佳工具。
厨师的缺点
Chef 的一些主要缺点如下 –
-
Chef 的一大缺点是控制食谱的方式。它需要不断的照顾，这样工作的人不应该弄乱别人的食谱。
-
只有厨师独奏可用。
-
在目前的情况下，它只适合 AWS 云。
-
如果这个人不熟悉Ruby，学习起来就不是很容易。
-
文档仍然缺乏。
Chef 的关键构建块
食谱
它可以定义为用于管理基础设施的属性集合。配方中存在的这些属性用于更改现有状态或设置特定基础设施节点。它们在 Chef 客户端运行期间加载并与节点（机器）的现有属性进行比较。然后它进入在配方的节点资源中定义的状态。它是食谱的主要主力。
食谱
食谱是食谱的集合。它们是上传到 Chef 服务器的基本构建块。当 Chef 运行时，它会确保其中的配方使给定的基础设施达到配方中列出的所需状态。
资源
它是用于管理具有不同类型状态的基础设施的配方的基本组件。一个配方中可以有多个资源，这将有助于配置和管理基础设施。例如 –
-
package – 管理节点上的包
-
service – 管理节点上的服务
-
user – 管理节点上的用户
-
group – 管理组
-
模板– 使用嵌入式 Ruby 模板管理文件
-
cookbook_file – 将文件从说明书中的文件子目录传输到节点上的某个位置
-
file – 管理节点上文件的内容
-
directory – 管理节点上的目录
-
execute – 在节点上执行命令
-
cron – 编辑节点上现有的 cron 文件
属性
它们基本上是设置。它们可以被认为是人们想要在食谱中使用的任何东西的键值对。有几种不同类型的属性可以应用，与节点操作的最终设置相比具有不同的优先级。
文件
它是说明书中的一个子目录，其中包含将放置在使用说明书的节点上的任何静态文件。然后可以将配方声明为将文件从该目录移动到最终节点的资源。
模板
它们类似于文件，但它们不是静态的。模板文件以 .ebr 扩展名结尾，这意味着它们包含嵌入式 Ruby。它们主要用于将属性值替换到文件中以创建将放置在节点上的最终文件版本。
元数据文件
它用于管理有关包的元数据。这包括包的名称和详细信息等详细信息。它还包括诸如依赖信息之类的东西，这些信息告诉此说明书需要操作哪些说明书。这允许 Chef 服务器正确构建节点的运行列表，并确保正确传输所有部分。
默认食谱结构
C:\chef\cookbooks\nginx>tree
Folder PATH listing for volume Local Disk
Volume serial number is BE8B-6427
C: ├───attributes
├───definitions
├───files
│ └───default
├───libraries
├───providers
├───recipes
├───resources
└───templates
└───default
Chef – 相关技术
以下是 Chef 相关技术的列表。
木偶
无论软件在何处运行，Puppet 都提供了一种交付和操作软件的标准方式。它是 Linux、Unix 和 Windows 系统的自动化管理引擎，基于集中规范执行管理任务。
Puppet的主要特点如下 –
- 实施具有统一配置的新系统。
- 更新系统并升级安全和软件包。
- 结合新功能并添加灵巧功能。
- 自定义配置以确保数据源的可用性。
- 优化可用资源并最小化成本。
- 简化角色并使团队能够专注于核心和生产性问题。
- 鸟瞰可用的基础设施。
Ansible
Ansible 是一个极其简单的 IT 自动化平台，可让您的应用程序和系统更易于部署。避免编写脚本或自定义代码来部署和更新您的应用程序 — 使用接近纯英语的语言进行自动化，使用 SSH，无需在远程系统上安装代理。
Ansible的主要功能如下 –
- 简单易学
- 用 Python 编写
- 无代理
- 基于 YAML 的剧本
- Ansible 星系
盐堆
SaltStack 用于数据驱动的配置。它是一种建立在动态通信总线上的基础设施管理新方法。它用于数据驱动的编排、任何基础设施的远程执行以及任何应用程序堆栈的配置管理。
织物
Fabric是一种基于 Python 的编程语言，它是作为 Python 的 API 开发的，需要在 Python 代码中导入以配置和管理基础设施。
厨师 – 建筑
Chef 在三层客户端服务器模型上工作，其中在 Chef 工作站上开发诸如食谱之类的工作单元。从命令行实用程序（例如 Knife），它们被上传到 Chef 服务器，并且架构中存在的所有节点都向 Chef 服务器注册。
为了让可用的 Chef 基础设施就位，我们需要按顺序设置多个东西。
在上面的设置中，我们有以下组件。
厨师工作站
这是开发所有配置的位置。Chef 工作站安装在本地机器上。详细的配置结构将在本教程的后面章节中讨论。
厨师服务器
这是 Chef 设置的集中工作单元，所有配置文件都在开发后上传。有不同种类的 Chef 服务器，有些是托管的 Chef 服务器，而有些是内置的。
厨师节点
它们是将由 Chef 服务器管理的实际机器。所有节点都可以根据需要进行不同类型的设置。Chef 客户端是所有节点的关键组件，它有助于建立 Chef 服务器和 Chef 节点之间的通信。Chef 节点的其他组件是 Ohai，它有助于获取任何节点在给定时间点的当前状态。
Chef – 版本控制系统设置
使用版本控制系统是基础设施自动化的基本部分。有SVN、CVS、GIT等多种版本控制系统。由于 GIT 在 Chef 社区中的流行，我们将使用 GIT 设置。
注意– 不要将基础设施构建为没有版本控制系统的代码。
在 Windows 上
步骤 1 – 从www.git-scm.org下载 Windows 安装程序并按照安装步骤操作。
第 2 步– 在 GitHub 上注册中央存储库。
第 3 步– 将 ssh 密钥上传到 GitHub 帐户，以便可以轻松与之交互。有关 ssh 密钥的详细信息，请访问以下链接https://help.github.com/articles/generatessh-keys。
第 4 步– 最后通过访问https://github.com/new以 Chef-repo 的名称在 github 帐户上创建一个repo。
在真正开始编写说明书之前，可以在开发箱上设置一个初始的 GIT 存储库，并克隆 Opscode 提供的空存储库。
步骤 1 – 下载 Opscode Chef 存储库空结构。
$ wget https://github.com/opscode/chef-repo/tarball/master
步骤 2 – 提取焦油球。
$ tar –xvf master
步骤 3 – 重命名目录。
$ mv opscode-chef-repo-2c42c6a/ chef-repo
第 4 步– 将当前工作目录更改为 Chef repo。
$ cd chef-repo
第 5 步– 初始化一个新的 get 存储库。
$ git init.
第 6 步– 在 git hub 上连接到您的存储库。
$ git remote add origin [email protected]:vipin022/chef-
第 7 步– 将本地存储库推送到 github。
$ git add. $ git commit –m “empty repo structure added” $ git push –u origin maste
通过使用上述过程，您将获得一个空的厨师存储库。然后，您可以开始开发食谱和食谱。完成后，您可以将更改推送到 GitHub。
Chef – 工作站设置
Chef 遵循客户端-服务器架构的概念，因此为了开始使用 Chef，需要在工作站上设置 Chef 并在本地开发配置。稍后它可以上传到 Chef 服务器，使它们在需要配置的 Chef 节点上工作。
Opscode 提供了一个完全打包的版本，它没有任何外部先决条件。这个完全打包的 Chef 称为omnibus 安装程序。
在 Windows 机器上
步骤 1 – 在机器上下载 ChefDK 的 setup .msi 文件。
步骤 2 – 按照安装步骤将其安装在目标位置。
设置将如下面的屏幕截图所示。
ChefDK 路径变量
$ echo $PATH /c/opscode/chef/bin:/c/opscode/chefdk/bin:
在 Linux 机器上
为了在 Linux 机器上进行设置，我们需要先在机器上获取 curl。
第 1 步– 一旦在机器上安装了 curl，我们需要使用 Opscode 的综合 Chef 安装程序在工作站上安装 Chef。
$ curl –L https://www.opscode.com/chef/install.sh | sudo bash
第 2 步– 在机器上安装 Ruby。
第 3 步– 将 Ruby 添加到路径变量。
$ echo ‘export PATH = ”/opt/chef/embedded/bin:$PATH”’ &Gt ~/.bash_profile && source ~/.bash_profile
Omnibus Chef 将通过将/opt/chef/embedded/bin目录添加到 .bash_profile 文件，将 Ruby 和所有必需的 Ruby gem 安装到/opt/chef/embedded 中。
如果已经安装了 Ruby，则通过运行以下命令在机器上安装 Chef Ruby gem。
$ gem install chef
Chef – 客户端设置
为了让 Chef 节点与 Chef 服务器进行通信，您需要在该节点上设置 Chef 客户端。
厨师客户
这是 Chef 节点的关键组件之一，它从 Chef 服务器检索食谱并在节点上执行它们。它也称为 Chef 配置器。
在这里，我们将使用 Vagrant 来管理 VM。Vagrant 还可以使用配置程序（例如 Shell 脚本、Chef 和 Puppet）进行配置，以使 VM 进入所需状态。在我们的例子中，我们将使用 Vagrant 来管理虚拟机，使用 VirtualBox 和 Chef 客户端作为供应商。
第 1 步– 从https://www.virtualbox.org/wiki/downlod下载并安装 VirtualBox
第 2 步– 在http://downloads.vagrantup.com下载并安装 Vagrant
第 3 步– 安装 Vagrant Omnibus 插件，使 Vagrant 能够在 VM 上安装 Chef 客户端。
$ vagrant plugin install vagrant-omnibus
创建和启动虚拟
第 1 步– 我们可以从 Opscode vagrant repo 下载所需的 Vagrant 框。从以下 URL https://opscode-vmbento.s3.amazonaws.com/vagrant/opscode_ubuntu-12.04_provisionerless.box下载 opscode-ubuntu-12.04 框
第 2 步– 获得 Vagrant 文件后，下载编辑 Vagrant 文件所需的路径。
vipin@laptop:~/chef-repo $ subl Vagrantfile
Vagrant.configure("2") do |config|
config.vm.box = "opscode-ubuntu-12.04"
config.vm.box_url = https://opscode-vm-bento.s3.amazonaws.com/
vagrant/opscode_ubuntu-12.04_provisionerless.box
config.omnibus.chef_version = :latest
config.vm.provision :chef_client do |chef|
chef.provisioning_path = "/etc/chef"
chef.chef_server_url = "https://api.opscode.com/
organizations/<YOUR_ORG>"
chef.validation_key_path = "/.chef/<YOUR_ORG>-validator.pem"
chef.validation_client_name = "<YOUR_ORG>-validator"
chef.node_name = "server"
end
end
在上述程序中，您需要使用正确或所需的组织名称更新 <YOUR_ORG> 名称。
步骤 3 – 配置后的下一步是启动 vagrant 框。为此，您需要移动到 Vagrant 框所在的位置并运行以下命令。
$ vagrant up
步骤 4 – 机器启动后，您可以使用以下命令登录机器。
$ vagrant ssh
在上面的命令中，vagrantfile 是用 Ruby 域特定语言 (DSL) 编写的，用于配置 vagrant 虚拟机。
在 vagrant 文件中，我们有配置对象。Vagrant 将使用这个配置对象来配置 VM。
Vagrant.configure("2") do |config|
…….
End
在配置块中，您将告诉 vagrant 要使用哪个 VM 映像，以便引导节点。
config.vm.box = "opscode-ubuntu-12.04" config.vm.box_url = https://opscode-vm-bento.s3.amazonaws.com/ vagrant/opscode_ubuntu-12.04_provisionerless.box
在下一步中，您将告诉 Vagrant 下载综合插件。
config.omnibus.chef_version = :latest
选择要启动的 VM 框后，配置如何使用 Chef 配置该框。
config.vm.provision :chef_client do |chef| ….. End
在其中，您需要设置有关如何将虚拟节点连接到 Chef 服务器的说明。你需要告诉 Vagrant 你需要在节点上存储所有 Chef 的东西。
chef.provisioning_path = "/etc/chef"
厨师 – 测试厨房设置
Test Kitchen 是 Chef 的集成测试框架。它支持编写测试配方，一旦它们使用说明书进行实例化和融合，这些测试配方就会在 VM 上运行。测试配方在该 VM 上运行，可以验证一切是否按预期工作。
ChefSpec是只模拟 Chef 运行的东西。测试厨房启动真实节点并在其上运行 Chef。
第 1 步– 安装 test kitchen Ruby gem 和 test kitchen vagrant gem，使 test kitchen 能够使用 vagrant 进行测试。
$ gem install kitchen $ gem install kitchen-vagrant
第 2 步– 设置测试厨房。这可以通过在食谱目录中创建.kitchen.yml来完成。
driver_plugin: vagrant
driver_config:
require_chef_omnibus: true
platforms:
- name: ubuntu-12.04
driver_config:
box: opscode-ubuntu-12.04
box_url: https://opscode-vm.s3.amazonaws.com/vagrant/opscode_
ubuntu-12.04_provisionerless.box
suites:
- name: default
run_list:
- recipe[minitest-handler]
- recipe[my_cookbook_test]
attributes: { my_cookbook: { greeting: 'Ohai, Minitest!'} }
在上面的代码中，有一部分定义了 vagrant 需要启动虚拟机，它定义了您希望 Omnibus 在目标节点上安装 Chef。
第二部分定义了您要测试食谱的平台。Vagrant 总是会创建和销毁新实例。您不必担心使用 Vagrant 文件启动的 Vagrant VM 的副作用。
测试厨房可以被视为一个临时环境，有助于在类似于生产的临时环境中运行和测试食谱。启用测试厨房后，可以确保给定的代码段在实际部署到测试、预生产和生产环境之前可以正常工作。在将食谱放入实际工作环境之前，测试厨房的这一功能被许多组织作为一套遵循。
测试厨房工作流程
以下是测试厨房工作流程中涉及的步骤。
使用 Chef 创建食谱
使用以下代码创建食谱。
$ chef generate cookbook motd_rhel
Installing Cookbook Gems:
Compiling Cookbooks...
Recipe: code_generator::cookbook
* directory[C:/chef/cookbooks/motd_rhel] action create
- create new directory C:/chef/cookbooks/motd_rhel
* template[C:/chef/cookbooks/motd_rhel/metadata.rb] action create_if_missing
- create new file C:/chef/cookbooks/motd_rhel/metadata.rb
- update content in file C:/chef/cookbooks/motd_rhel/metadata.rb from none to
d6fcc2 (diff output suppressed by config)
* template[C:/chef/cookbooks/motd_rhel/README.md] action create_if_missing
- create new file C:/chef/cookbooks/motd_rhel/README.md
- update content in file C:/chef/cookbooks/motd_rhel/README.md from none to 50deab
(diff output suppressed by config)
* cookbook_file[C:/chef/cookbooks/motd_rhel/chefignore] action create
- create new file C:/chef/cookbooks/motd_rhel/chefignore
- update content in file C:/chef/cookbooks/motd_rhel/chefignore from none to 15fac5
(diff output suppressed by config)
* cookbook_file[C:/chef/cookbooks/motd_rhel/Berksfile] action create_if_missing
- create new file C:/chef/cookbooks/motd_rhel/Berksfile
- update content in file C:/chef/cookbooks/motd_rhel/Berksfile from none to 9f08dc
(diff output suppressed by config)
* template[C:/chef/cookbooks/motd_rhel/.kitchen.yml] action create_if_missing
- create new file C:/chef/cookbooks/motd_rhel/.kitchen.yml
- update content in file C:/chef/cookbooks/motd_rhel/.kitchen.yml
from none to 49b92b (diff output suppressed by config)
* directory[C:/chef/cookbooks/motd_rhel/test/integration/default/serverspec]
action create
- create new directory
C:/chef/cookbooks/motd_rhel/test/integration/default/serverspec
* directory[C:/chef/cookbooks/motd_rhel/test/integration/helpers/serverspec]
action create
- create new directory
C:/chef/cookbooks/motd_rhel/test/integration/helpers/serverspec
* cookbook_file
[C:/chef/cookbooks/motd_rhel/test/integration/helpers/serverspec/spec_helper.rb]
action create_if_missing
- create new file
C:/chef/cookbooks/motd_rhel/test/integration/helpers/serverspec/spec_helper.rb
- update content in file
C:/chef/cookbooks/motd_rhel/test/integration/helpers/serverspec/spec_helper.rb
from none to d85df4 (diff output suppressed by config)
* template
[C:/chef/cookbooks/motd_rhel/test/integration/default/serverspec/defaul t_spec.rb]
action create_if_missing
- create new file
C:/chef/cookbooks/motd_rhel/test/integration/default/serverspec/default_spec.rb
- update content in file
C:/chef/cookbooks/motd_rhel/test/integration/default/serverspec/default_spec.rb
from none to 3fbdbd (diff output suppressed by config)
* directory[C:/chef/cookbooks/motd_rhel/spec/unit/recipes] action create
- create new directory C:/chef/cookbooks/motd_rhel/spec/unit/recipes
* cookbook_file
[C:/chef/cookbooks/motd_rhel/spec/spec_helper.rb] action create_if_missing
- create new file C:/chef/cookbooks/motd_rhel/spec/spec_helper.rb
- update content in file
C:/chef/cookbooks/motd_rhel/spec/spec_helper.rb from none to 587075
(diff output suppressed by config)
* template
[C:/chef/cookbooks/motd_rhel/spec/unit/recipes/default_spec.rb]
action create_if_missing
- create new file C:/chef/cookbooks/motd_rhel/spec/unit/recipes/default_spec.rb
- update content in file
C:/chef/cookbooks/motd_rhel/spec/unit/recipes/default_spec.rb
from none to ff3b17 (diff output suppressed by config)
* directory[C:/chef/cookbooks/motd_rhel/recipes] action create
- create new directory C:/chef/cookbooks/motd_rhel/recipes
* template[C:/chef/cookbooks/motd_rhel/recipes/default.rb] action create_if_missing
- create new file C:/chef/cookbooks/motd_rhel/recipes/default.rb
- update content in file
C:/chef/cookbooks/motd_rhel/recipes/default.rb from none to c4b029
(diff output suppressed by config)
* execute[initialize-git] action run
- execute git init .
* cookbook_file[C:/chef/cookbooks/motd_rhel/.gitignore] action create
- create new file C:/chef/cookbooks/motd_rhel/.gitignore
- update content in file C:/chef/cookbooks/motd_rhel/.gitignore from none to 33d469
(diff output suppressed by config)
* execute[git-add-new-files] action run
- execute git add .
* execute[git-commit-new-files] action run
- execute git commit -m "Add generated cookbook content"
以下是作为上述代码输出的 Created Cookbook Structure。
测试厨房配置文件
.kitchen.yaml 文件
driver:
name: vagrant
provisioner:
name: chef_zero
# verifier:
# name: inspec
# format: doc
platforms:
- name: ubuntu-14.04
suites:
- name: default
run_list:
- recipe[motd_rhel::default]
attributes:
驱动程序– 它指定管理机器的软件。
Provisioner – 它提供了关于 Chef 如何运行的规范。我们使用chef_zero是因为它可以模拟本地机器上的Chef服务器环境。这允许使用节点属性和 Chef 服务器规范。
平台– 这指定了目标操作系统。
套件– 它定义了想要在虚拟环境中应用的内容。在这里，您定义多重定义。它是您定义运行列表的位置，它指定要运行的配方以及我们需要运行的顺序。
按顺序运行命令
厨房清单
$ kitchen list Instance Driver Provisioner Verifier Transport Last Action ubuntu-1404 Vagrant ChefZero Busser Ssh <Not Created>
厨房创造
$ kitchen create
-----> Starting Kitchen (v1.4.2)
-----> Creating <default-centos-72>...
Bringing machine 'default' up with 'virtualbox' provider...
==> default: Box 'opscode-centos-7.2' could not be found.
Attempting to find and install...
default: Box Provider: virtualbox
default: Box Version: >= 0
==> default: Box file was not detected as metadata. Adding it directly...
==> default: Adding box 'opscode-centos-7.2' (v0) for provider: virtualbox
default: Downloading:
https://opscode-vmbento.s3.amazonaws.com/vagrant/virtualbox/
opscode_centos-7.1_chefprovisionerless.box[...]
Vagrant instance <default-centos-72> created.
Finished creating <default-centos-72> (3m12.01s).
-----> Kitchen is finished. (3m12.60s)
厨房融合
$ kitchen converge
-----> Converging <default-centos-72>...
Preparing files for transfer
Preparing dna.json
Resolving cookbook dependencies with Berkshelf 4.0.1...
Removing non-cookbook files before transfer
Preparing validation.pem
Preparing client.rb
-----> Chef Omnibus installation detected (install only if missing)
Transferring files to <default-centos-72>
Starting Chef Client, version 12.6.0
resolving cookbooks for run list: ["motd_rhel::default"]
Synchronizing Cookbooks: - motd_rhel (0.1.0)
Compiling Cookbooks... Converging 1 resources
Recipe: motd_rhel::default (up to date)
Running handlers: Running handlers complete
Chef Client finished, 0/1 resources updated in 01 seconds
Finished converging <default-centos-72> (0m3.57s).
-----> Kitchen is finished. (0m4.55s)
测试设置
Kitchen login 用于测试是否正确配置了测试 VM。
$ kitchen login Last login: Thu Jan 30 19:02:14 2017 from 10.0.2.2 hostname: default-centos-72 fqdn: default-centos-72 memory: 244180kBcpu count: 1
最后退出
$ exit Logout Connection to 127.0.0.1 closed.
破坏设置
$ Kitchen destroy -----> Starting Kitchen (v1.4.2) -----> Destroying <default-centos-72>... ==> default: Forcing shutdown of VM... ==> default: Destroying VM and associated drives... Vagrant instance <default-centos-72> destroyed. Finished destroying <default-centos-72> (0m4.94s). -----> Kitchen is finished. (0m5.93s)
厨师 – 刀具设置
Knife 是 Chef 的命令行工具，用于与 Chef 服务器进行交互。一个人用它来上传食谱和管理 Chef 的其他方面。它提供了本地机器上的 ChefDK（Repo）和 Chef 服务器之间的接口。它有助于管理 –
- 厨师节点
- 食谱
- 食谱
- 环境
- 云资源
- 云配置
- 在 Chef 节点上的 Chef 客户端上安装
Knife 提供了一组命令来管理 Chef 基础设施。
引导命令
- 刀引导[SSH_USER@]FQDN（选项）
客户端命令
- 刀客户端批量删除正则表达式（选项）
- 刀客户端创建 CLIENTNAME（选项）
- 刀客户端删除客户端（选项）
- 刀客户端编辑客户端（选项）
- 用法：C:/opscode/chef/bin/knife（选项）
- 刀客户端密钥删除客户端密钥名称（选项）
- 刀客户端密钥编辑 CLIENT KEYNAME（选项）
- 刀客户端密钥列表客户端（选项）
- 刀客户端密钥显示客户端密钥名称（选项）
- Knife客户列表（选项）
- 刀客户端重新注册客户端（选项）
- 刀客户端显示客户端（选项）
配置命令
- 刀配置（选项）
- 刀配置客户端目录
食谱命令
- 刀食谱批量删除正则表达式（选项）
- 刀食谱创建食谱（选项）
- 刀食谱删除食谱版本（选项）
- 刀食谱下载食谱[版本]（选项）
- 刀食谱清单（选项）
- 刀食谱元数据 COOKBOOK（选项）
- 文件中的刀食谱元数据（选项）
- 刀食谱显示 COOKBOOK [版本] [部分] [文件名]（选项）
- 刀食谱测试 [COOKBOOKS …]（选项）
- 刀食谱上传 [COOKBOOKS …]（选项）
食谱站点命令
- 刀食谱网站下载食谱[版本]（选项）
- 刀食谱网站安装食谱[版本]（选项）
- 刀食谱网站列表（选项）
- 刀食谱网站搜索查询（选项）
- 刀食谱网站分享食谱[CATEGORY]（选项）
- 刀食谱网站显示 COOKBOOK [版本]（选项）
- 刀食谱网站取消共享食谱
数据包命令
- Knife data bag create BAG [ITEM]（选项）
- 刀数据包删除包[ITEM]（选项）
- 刀数据包编辑 BAG ITEM（选项）
- 来自文件 BAG FILE|FOLDER [FILE|FOLDER..] 的 Knife 数据包（选项）
- 刀数据包列表（选项）
- 刀数据包显示 BAG [ITEM]（选项）
环境命令
- 刀环境比较 [ENVIRONMENT..]（选项）
- 刀环境创建环境（选项）
- 刀环境删除环境（选项）
- 刀环境编辑环境（选项）
- 文件 FILE [FILE..] 中的 Knife 环境（选项）
- 刀环境列表（选项）
- 刀环境显示环境（选项）
执行命令
- Knife exec [SCRIPT]（选项）
帮助命令
- 刀帮助 [列表|主题]
索引命令
- 刀索引重建（选项）
节点命令
- 刀节点批量删除正则表达式（选项）
- 刀节点创建节点（选项）
- 刀节点删除节点（选项）
- 刀节点编辑节点（选项）
- 刀节点环境设置节点环境
- 文件 FILE 中的 Knife 节点（选项）
- 刀节点列表（选项）
- Knife node run_list add [NODE] [ENTRY[,ENTRY]] (options)
- Knife node run_list remove [NODE] [ENTRY[,ENTRY]] (options)
- 刀节点 run_list 设置节点条目（选项）
- 刀节点显示节点（选项）
OSC 命令
- 刀 osc_user 创建用户（选项）
- 刀 osc_user 删除用户（选项）
- 刀 osc_user 编辑用户（选项）
- 刀 osc_user 列表（选项）
- 刀 osc_user 重新注册用户（选项）
- 刀 osc_user 显示用户（选项）
基于路径的命令
- 刀删除 [PATTERN1 … PATTERNn]
- 刀 deps PATTERN1 [PATTERNn]
- 刀差异模式
- 刀下载模式
- 刀编辑 [PATTERN1 … PATTERNn]
- 刀列表 [-dfR1p] [PATTERN1 … PATTERNn]
- 刀秀 [PATTERN1 … PATTERNn]
- 刀上传模式
- 刀 xargs [命令]
原始命令
- 刀原始 REQUEST_PATH
配方命令
- 刀食谱列表 [图案]
角色命令
- 刀角色批量删除正则表达式（选项）
- 刀角色创建角色（选项）
- 刀角色删除角色（选项）
- 刀角色编辑角色（选项）
- 刀角色 env_run_list 添加 [ROLE] [ENVIRONMENT] [ENTRY[,ENTRY]]（选项）
- 刀角色 env_run_list 清除 [角色] [环境]
- 刀角色 env_run_list 删除 [ROLE] [ENVIRONMENT] [ENTRIES]
- 刀角色 env_run_list 替换 [ROLE] [ENVIRONMENT] [OLD_ENTRY] [NEW_ENTRY]
- 刀角色 env_run_list 设置 [ROLE] [ENVIRONMENT] [ENTRIES]
- 文件 FILE [FILE..] 中的 Knife 角色（选项）
- 刀角色列表（选项）
- 刀角色 run_list 添加 [ROLE] [ENTRY[,ENTRY]]（选项）
- 刀角色 run_list 清除 [ROLE]
- 刀角色 run_list 删除 [ROLE] [ENTRY]
- 刀角色 run_list 替换 [ROLE] [OLD_ENTRY] [NEW_ENTRY]
- 刀角色 run_list 设置 [ROLE] [ENTRIES]
- 刀角色显示角色（选项）
服务命令
- 刀服务（选项）
SSH 命令
- 刀 ssh 查询命令（选项）
SSL 命令
- 刀 ssl 检查 [URL]（选项）
- 刀 ssl 获取 [URL]（选项）
状态命令
- 刀状态查询（选项）
标签命令
- 刀标签创建节点标签…
- 刀标签删除节点标签…
- 刀标签列表节点
用户命令
- Knife用户创建USERNAME DISPLAY_NAME FIRST_NAME LAST_NAME EMAIL PASSWORD（选项）
- 刀用户删除用户（选项）
- 刀用户编辑用户（选项）
- 刀用户密钥创建用户（选项）
- 刀用户密钥删除用户密钥名称（选项）
- 刀用户密钥编辑用户密钥名称（选项）
- 刀用户密钥列表 USER（选项）
- 刀用户密钥显示用户密钥名称（选项）
- 刀用户列表（选项）
- 刀用户重新注册用户（选项）
- 刀用户显示用户（选项）
刀具设置
为了设置knife，需要移动到.chef目录并在chef repo 中创建一个knife.rb，它告诉knife 配置细节。这将有一些细节。
current_dir = File.dirname(__FILE__)
log_level :info
log_location STDOUT
node_name 'node_name'
client_key "#{current_dir}/USER.pem"
validation_client_name 'ORG_NAME-validator'
validation_key "#{current_dir}/ORGANIZATION-validator.pem"
chef_server_url 'https://api.chef.io/organizations/ORG_NAME'
cache_type 'BasicFile'
cache_options( :path => "#{ENV['HOME']}/.chef/checksums" )
cookbook_path ["#{current_dir}/../cookbooks"]
在上面的代码中，我们使用托管的 Chef 服务器，它使用以下两个密钥。
validation_client_name 'ORG_NAME-validator'
validation_key "#{current_dir}/ORGANIZATION-validator.pem"
在这里，knife.rb 告诉knife 使用哪个组织以及在哪里可以找到私钥。它告诉刀在哪里可以找到用户的私钥。
client_key "#{current_dir}/USER.pem"
下面这行代码告诉knife我们使用的是托管服务器。
chef_server_url 'https://api.chef.io/organizations/ORG_NAME'
使用 Knife.rb 文件，验证刀现在可以连接到您组织的托管 Opscode。
厨师 – 单人设置
Chef-Solo 是一个在本地运行的开源工具，允许使用 Chef 说明书配置来宾机器，而无需任何 Chef 客户端和服务器配置的复杂性。它有助于在自创建的服务器上执行说明书。
在本地机器上运行 Chef-Solo 之前，需要在本地机器上安装以下两个文件。
-
Solo.rb – 该文件告诉 Chef 在哪里可以找到食谱、角色和数据包。
-
Node.json – 如果需要，此文件设置运行列表和任何特定于节点的属性。
solo.rb 配置
以下是配置 solo.rb 的步骤。
第 1 步– 在 Chef 存储库中创建一个 solo.rb 文件。
current_dir = File.expand_path(File.dirname(__FILE__))
file_cache_path "#{current_dir}"
cookbook_path "#{current_dir}/cookbooks"
role_path "#{current_dir}/roles"
data_bag_path "#{current_dir}/data_bags"
第 2 步– 将文件添加到 git repo。
$ git add solo.rb
第 3 步– 在 Chef 存储库中创建一个包含以下内容的 node.json 文件。
{
"run_list": [ "recipe[ntp]" ]
}
第 4 步– 使用刀在厨师仓库中获取 ntp 食谱。
vipin@laptop:~/chef-repo $ knife cookbook site install ntp Installing ntp to /Users/mma/work/chef-repo/cookbooks …TRUNCATED OUTPUT… Cookbook ntp version 1.3.0 successfully installed
第 5 步– 将 node.json 文件添加到 Git。
$ git add node.json
第 6 步– 提交文件并将其推送到 git repo。
vipin@laptop:~/chef-repo $ git commit -m "initial setup for Chef Solo" vipin@laptop:~/chef-repo $ git push Counting objects: 4, done. Delta compression using up to 4 threads. ...TRUNCATED OUTPUT... To [email protected]:mmarschall/chef-repo.git b930647..5bcfab6 master -> master
在节点上运行说明书
步骤 1 – 登录到想要配置 Chef-Solo 的节点。
第 2 步– 在机器上克隆 Chef 存储库。
$ git clone $URL_PATH
第 3 步– cd 到chef repo。
$ cd chef-repo
最后，运行 Chef-Solo 以收敛节点 –
$ sudo chef-solo -c solo.rb -j node.json [2017-20-08T22:54:13+01:00] INFO: *** Chef 11.0.0 *** [2017-20-08T22:54:13+01:00] INFO: Setting the run_list to ["recipe[ntp]"] from JSON ...TRUNCATED OUTPUT... [2012-12-08T22:54:16+01:00] INFO: Chef Run complete in 2.388374 seconds [2012-12-08T22:54:16+01:00] INFO: Running report handlers
solo.rb将 Chef-Solo 配置为在当前目录中查找其食谱、角色和数据包：Chef 存储库。
Chef-Solo从 JSON 文件中获取其节点配置。在我们的示例中，我们将其称为 node.json。如果您要管理多个服务器，则每个节点都需要一个单独的文件。然后，Chef-Solo 仅根据在 solo.rb 和 node.json 中找到的配置数据执行 Chef 运行。
厨师 – 食谱
Cookbooks 是 Chef 的基本工作单元，它包含与工作单元相关的所有详细信息，能够修改配置为 Chef 基础架构上的节点的任何系统的配置和状态。食谱可以执行多项任务。Cookbooks 包含有关节点所需状态的值。这是通过使用所需的外部库在 Chef 中实现的。
食谱的关键组成部分
- 食谱
- 元数据
- 属性
- 资源
- 模板
- 图书馆
- 任何其他有助于创建系统的东西
创建食谱
有两种方法可以动态创建食谱。
- 使用厨师命令
- 使用刀具实用程序
使用厨师命令
要使用 Chef 命令创建空说明书，请运行以下命令。
C:\Users\vipinkumarm>chef generate cookbook <Cookbook Name>
C:\Users\vipinkumarm>chef generate cookbook VTest
Installing Cookbook Gems:
Compiling Cookbooks...
Recipe: code_generator::cookbook
* directory[C:/Users/vipinkumarm/VTest] action create
- create new directory C:/Users/vipinkumarm/VTest
* template[C:/Users/vipinkumarm/VTest/metadata.rb] action create_if_missing
- create new file C:/Users/vipinkumarm/VTest/metadata.rb
- update content in file C:/Users/vipinkumarm/VTest/metadata.rb
from none to 4b9435 (diff output suppressed by config)
* template[C:/Users/vipinkumarm/VTest/README.md] action create_if_missing
- create new file C:/Users/vipinkumarm/VTest/README.md
- update content in file C:/Users/vipinkumarm/VTest/README.md
from none to 482077 (diff output suppressed by config)
* cookbook_file[C:/Users/vipinkumarm/VTest/chefignore] action create
- create new file C:/Users/vipinkumarm/VTest/chefignore
- update content in file C:/Users/vipinkumarm/VTest/chefignore
from none to 15fac5 (diff output suppressed by config)
* cookbook_file[C:/Users/vipinkumarm/VTest/Berksfile] action create_if_missing
- create new file C:/Users/vipinkumarm/VTest/Berksfile
- update content in file C:/Users/vipinkumarm/VTest/Berksfile
from none to 9f08dc (diff output suppressed by config)
* template[C:/Users/vipinkumarm/VTest/.kitchen.yml] action create_if_missing
- create new file C:/Users/vipinkumarm/VTest/.kitchen.yml
- update content in file C:/Users/vipinkumarm/VTest/.kitchen.yml
from none to 93c5bd (diff output suppressed by config)
* directory[C:/Users/vipinkumarm/VTest/test/integration/default/serverspec]
action create
- create new directory
C:/Users/vipinkumarm/VTest/test/integration/default/serverspec
* directory[C:/Users/vipinkumarm/VTest/test/integration/helpers/serverspec]
action create
- create new directory
C:/Users/vipinkumarm/VTest/test/integration/helpers/serverspec
* cookbook_file
[C:/Users/vipinkumarm/VTest/test/integration/helpers/serverspec/sp ec_helper.rb]
action create_if_missing
- create new file
C:/Users/vipinkumarm/VTest/test/integration/helpers/serverspec/spec_helper.rb
- update content in file
C:/Users/vipinkumarm/VTest/test/integration/helpers/serverspec/spec_helper.rb
from none to d85df4 (diff output suppressed by config)
* template
[C:/Users/vipinkumarm/VTest/test/integration/default/serverspec/default _spec.rb]
action create_if_missing
- create new file
C:/Users/vipinkumarm/VTest/test/integration/default/serverspec/default_spec.rb
- update content in file
C:/Users/vipinkumarm/VTest/test/integration/default/serverspec/default_spec.rb
from none to 758b94 (diff output suppressed by config)
* directory[C:/Users/vipinkumarm/VTest/spec/unit/recipes] action create
- create new directory C:/Users/vipinkumarm/VTest/spec/unit/recipes
* cookbook_file[C:/Users/vipinkumarm/VTest/spec/spec_helper.rb]
action create_if_missing
- create new file C:/Users/vipinkumarm/VTest/spec/spec_helper.rb
- update content in file C:/Users/vipinkumarm/VTest/spec/spec_helper.rb
from none to 587075 (diff output suppressed by config)
* template[C:/Users/vipinkumarm/VTest/spec/unit/recipes/default_spec.rb]
action create_if_missing
- create new file C:/Users/vipinkumarm/VTest/spec/unit/recipes/default_spec.rb
- update content in file
C:/Users/vipinkumarm/VTest/spec/unit/recipes/default_spec.rb
from none to 779503 (diff output suppressed by config)
- create new file C:/Users/vipinkumarm/VTest/recipes/default.rb
- update content in file C:/Users/vipinkumarm/VTest/recipes/default.rb
from none to 8cc381 (diff output suppressed by config)
* cookbook_file[C:/Users/vipinkumarm/VTest/.gitignore] action create
- create new file C:/Users/vipinkumarm/VTest/.gitignore
- update content in file C:/Users/vipinkumarm/VTest/.gitignore from none to 33d469
(diff output suppressed by config)
将在目录中创建名为 VTest 的食谱结构，以下将是相同的结构。
使用刀具工具
使用以下命令使用 Knife 实用程序创建食谱。
C:\Users\vipinkumarm\VTest>knife cookbook create VTest2 WARNING: No knife configuration file found ** Creating cookbook VTest2 in C:/chef/cookbooks ** Creating README for cookbook: VTest2 ** Creating CHANGELOG for cookbook: VTest2 ** Creating metadata for cookbook: VTest2
以下将是食谱的结构。
Chef – Cookbook 依赖项
定义说明书依赖项的功能有助于管理说明书。当我们想在其他食谱中使用一本食谱的功能时使用此功能。
例如，如果要编译 C 代码，则需要确保安装了编译所需的所有依赖项。为了做到这一点，可能有单独的食谱可以执行这样的功能。
当我们使用chef-server 时，我们需要知道cookbooks 中的这些依赖项，这些依赖项应该在cookbooks 元数据文件中减速。该文件位于说明书目录结构的顶部。它向 Chef 服务器提供提示，这有助于在正确的节点上部署食谱。
metadata.rb 文件的特点
-
位于说明书目录结构的顶部。
-
当使用 Knife 命令将食谱上传到 Chef 服务器时编译。
-
使用 Knife Cookbook metadata 子命令编译。
-
当运行 Knife cookbook create 命令时自动创建。
metadata.rb 的配置
以下是元数据文件的默认内容。
厨师 – 角色
Chef 中的角色是对节点进行分组的一种逻辑方式。典型案例是拥有 Web 服务器、数据库服务器等角色。可以为所有节点设置自定义运行列表并覆盖角色内的属性值。
创建角色
vipin@laptop:~/chef-repo $ subl roles/web_servers.rb
name "web_servers"
description "This role contains nodes, which act as web servers"
run_list "recipe[ntp]"
default_attributes 'ntp' => {
'ntpdate' => {
'disable' => true
}
}
创建角色后，我们需要上传到 Chef 服务器。
将角色上传到 Chef 服务器
vipin@laptop:~/chef-repo $ knife role from file web_servers.rb
现在，我们需要为名为 server 的节点分配一个角色。
为节点分配角色
vipin@laptop:~/chef-repo $ knife node edit server "run_list": [ "role[web_servers]" ] Saving updated run_list on node server
运行 Chef 客户端
user@server:~$ sudo chef-client ...TRUNCATED OUTPUT... [2013-07-25T13:28:24+00:00] INFO: Run List is [role[web_servers]] [2013-07-25T13:28:24+00:00] INFO: Run List expands to [ntp] ...TRUNCATED OUTPUT...
这个怎么运作
-
在 Chef 存储库的角色文件夹内的 Ruby 文件中定义角色。
-
角色由名称和描述属性组成。
-
角色由特定于角色的运行列表和特定于角色的属性设置组成。
-
每个在其运行列表中具有角色的节点都将拥有该角色的运行列表。
-
角色运行列表中的所有配方都将在节点上执行。
-
该角色将使用来自文件命令的刀角色上传到 Chef 服务器。
-
该角色将被添加到节点运行列表中。
-
在其运行列表中具有该角色的节点上运行 Chef 客户端将执行该角色中列出的所有配方。
厨师 – 环境
Chef 有助于执行特定于环境的配置。为开发、测试和生产拥有一个单独的环境总是一个好主意。
Chef 支持将节点分组到不同的环境中，以支持有序的开发流程。
创建环境
可以使用 Knife 实用程序即时创建环境。以下命令将打开一个 Shell 的默认编辑器，以便可以修改环境定义。
vipin@laptop:~/chef-repo $ knife environment create book {
"name": "book",
"description": "",
"cookbook_versions": {
},
"json_class": "Chef::Environment",
"chef_type": "environment",
"default_attributes": {
},
"override_attributes": {
}
}
Created book
测试创建的环境
vipin@laptop:~/chef-repo $ knife environment list _default book
列出所有环境的节点
vipin@laptop:~/chef-repo $ knife node list my_server
_默认环境
每个组织将始终从至少一个称为默认环境的环境开始，该环境始终可用于 Chef 服务器。无论如何都不能修改默认环境。任何类型的更改都只能在我们创建的自定义环境中进行。
环境属性
属性可以在环境中定义，然后用于覆盖节点中的默认设置。当 Chef 客户端运行时，这些属性会与节点中已经存在的默认属性进行比较。当环境属性优先于默认属性时，Chef 客户端将在每个节点上运行 Chef 客户端时应用这些设置和值。
环境属性只能是 default_attribute 或 override_attribute。它不能是一个正常的属性。可以使用 default_attribute 或 override_attribute 方法。
属性类型
Default – 默认属性总是在每次 Chef 客户端运行开始时重置，并且具有最低的属性优先级。
Override – 覆盖属性总是在每次 Chef 客户端运行开始时重置，并且具有比 default、force_default 和 normal 更高的属性优先级。覆盖属性通常在配方中定义，但也可以在角色或环境的属性文件中指定。
应用属性的顺序
Chef – Chef-Client 作为守护进程
将 Chef-Client 作为守护进程运行有助于了解所有节点在任何时间点的状态。这有助于在任何时间点运行 Chef-Client。
先决条件
该节点应该注册到 Chef 服务器，并且它应该运行 Chef-Client 没有任何错误。
守护进程模式下的 Chef-Client
以守护进程模式启动 Chef-Client，每 30 分钟运行一次。
user@server:~$ sudo chef-client -i 1800
在上面的代码中，–i允许在所需节点上以守护程序模式运行 Chef-Client，1800 秒定义了 Chef-Client 守护程序应每 30 分钟运行一次。
验证守护进程运行
验证 Chef-Client 是否作为守护程序运行。
user@server:~$ ps auxw | grep chef-client
上面的命令将 grep 运行 Chef-Client 的守护进程。
其他方法
我们可以像cron job一样运行，而不是将 Chef-Client 作为守护进程运行。
user@server:~$ subl /etc/cron.d/chef_client PATH=/usr/local/bin:/usr/bin:/bin # m h dom mon dow user command */15 * * * * root chef-client -l warn | grep -v 'retrying [1234]/5 in'
上述 cron 作业将在每 15 分钟后运行一次。
厨师 – Chef-Shell
编写厨师食谱总是很困难。由于将它们上传到 Chef 服务器、配置流浪虚拟机、检查它们如何在那里失败、冲洗和重复的反馈周期很长，这使得它变得更加困难。如果我们可以在一次完成所有这些繁重的工作之前尝试测试一些片段或食谱，那会更容易。
Chef 带有 Chef-Shell，它本质上是与 Chef 的交互式 Ruby 会话。在 Chef-Shell 中，我们可以创建 –
- 属性
- 写食谱
- 初始化 Chef 运行
它用于在将部分食谱上传到 Chef 服务器并在节点上执行完整的食谱之前，即时评估部分食谱。
运行外壳
步骤 1 – 以独立模式运行 Chef-Shell。
mma@laptop:~/chef-repo $ chef-shell loading configuration: none (standalone chef-shell session) Session type: standalone Loading...[2017-01-12T20:48:01+01:00] INFO: Run List is [] [2017-01-12T20:48:01+01:00] INFO: Run List expands to [] done. This is chef-shell, the Chef Shell. Chef Version: 11.0.0 http://www.opscode.com/chef http://wiki.opscode.com/display/chef/Home run `help' for help, `exit' or ^D to quit. Ohai2u mma@laptop! chef >
第 2 步– 在 Chef-Shell 中切换到属性模式
-
厨师 > attributes_mode
步骤 3 – 设置属性值。
-
厨师：属性> set[:title] = “厨师食谱”
-
《厨师食谱》
-
-
厨师：属性 > 退出
-
：属性
-
-
厨师 >
步骤 4 – 切换到配方模式。
-
厨师 > recipe_mode
步骤 5 – 创建文件资源。
chef:recipe > file "/tmp/book.txt" do
chef:recipe > content node.title
chef:recipe ?> end
=> <file[/tmp/book.txt] @name: "/tmp/book.txt" @noop: nil @
before: nil @params: {} @provider: Chef::Provider::File @allowed_
actions: [:nothing, :create, :delete, :touch, :create_if_missing]
@action: "create" @updated: false @updated_by_last_action: false
@supports: {} @ignore_failure: false @retries: 0 @retry_delay:
2 @source_line: "(irb#1):1:in `irb_binding'" @elapsed_time: 0 @
resource_name: :file @path: "/tmp/book.txt" @backup: 5 @diff: nil
@cookbook_name: nil @recipe_name: nil @content: "Chef Cookbook">
chef:recipe >
第 6 步– 开始 Chef 运行以创建具有给定内容的文件。
-
厨师：食谱> run_chef
[2017-01-12T21:07:49+01:00] INFO: Processing file[/tmp/book.txt] action create ((irb#1) line 1) --- /var/folders/1r/_35fx24d0y5g08qs131c33nw0000gn/T/cheftempfile20121212- 11348-dwp1zs 2012-12-12 21:07:49.000000000 +0100 +++ /var/folders/1r/_35fx24d0y5g08qs131c33nw0000gn/T/chefdiff20121212- 11348-hdzcp1 2012-12-12 21:07:49.000000000 +0100 @@ -0,0 +1 @@ +Chef Cookbook \ No newline at end of file [2017-01-12T21:07:49+01:00] INFO: entered create [2017-01-12T21:07:49+01:00] INFO: file[/tmp/book.txt] created file /tmp/book.txt
这个怎么运作
-
Chef-Shell 以使用一些特定功能增强的交互式 Ruby (IRB) 会话开始。
-
它提供了诸如attributes_mode 和interactive_mode 等模式。
-
它有助于编写命令，这些命令写在食谱或食谱中。
-
它以交互模式运行一切。
我们可以在三种不同的模式下运行 Chef-Shell：独立模式、客户端模式和独奏模式。
-
独立模式– 这是默认模式。没有加载任何食谱，并且运行列表是空的。
-
客户端模式– 在这里，厨师壳充当厨师客户端。
-
独奏模式– 在这里，主厨壳充当主厨独奏客户端。
Chef – 测试食谱
如果说明书直接部署并在生产服务器上运行，说明书很可能会在生产中分解。防止这种情况发生的最好方法是在设置环境中测试说明书。
以下是测试步骤。
步骤 1 – 使用以下命令安装说明书。
vipin@laptop:~/chef-repo $ knife cookbook site install <cookbook name>
第 2 步– 在工作说明书上运行刀说明书测试命令。
vipin@laptop:~/chef-repo $ knife cookbook test VTest checking ntp Running syntax check on ntp Validating ruby files Validating templates
第 3 步– 打破食谱中的某些内容并再次测试。
vipin@laptop:~/chef-repo $ subl cookbooks/VTest/recipes/default.rb
...
[ node['ntp']['varlibdir']
node['ntp']['statsdir'] ].each do |ntpdir|
directory ntpdir do
owner node['ntp']['var_owner']
group node['ntp']['var_group']
mode 0755
end
end
步骤 4 – 再次运行刀具测试命令。
vipin@laptop:~/chef-repo $ knife cookbook test ntp checking ntp Running syntax check on ntp Validating ruby files FATAL: Cookbook file recipes/default.rb has a ruby syntax error: FATAL: cookbooks/ntp/recipes/default.rb:25: syntax error, unexpected tIDENTIFIER, expecting ']' FATAL: node['ntp']['statsdir'] ].each do |ntpdir| FATAL: ^ FATAL: cookbooks/ntp/recipes/default.rb:25: syntax error, unexpected ']', expecting $end FATAL: node['ntp']['statsdir'] ].each do |ntpdir| FATAL:
工作方法
Knife 食谱测试对食谱中的所有 Ruby 文件以及所有 ERB 模板执行 Ruby 语法检查。它遍历 Ruby 文件并对每个文件运行 Ruby –c。Ruby -c检查脚本的语法并退出而不运行它。
在遍历所有 Ruby 文件后，knife 食谱测试遍历所有 ERB 模板和管道，由–x到 Ruby –c创建的冗余版本。
限制
Knife Cookbook 测试仅对 Ruby 文件和 ERB 模板进行简单的语法检查。我们可以通过使用 ChefSpec 和 test kitchen 进行完全测试驱动。
厨师 – 美食评论家
编写没有任何问题的好食谱是一项艰巨的任务。但是有一些方法可以帮助识别陷阱。可以在 Chef Cookbook 中进行标记。Foodcritic 是最好的存档方式之一，它试图找出食谱的逻辑和风格可能存在的问题。
美食评论家设置
步骤 1 – 添加 Foodcritic gem。
vipin@laptop:~/chef-repo $ subl Gemfile source 'https://rubygems.org' gem 'foodcritic', '~>2.2.0'
步骤 2 – 安装 gem。
vipin@laptop:~/chef-repo $ bundle install Fetching gem metadata from https://rubygems.org/ ...TRUNCATED OUTPUT... Installing foodcritic (2.2.0)
美食评论家宝石
第 1 步– 在食谱上运行 Foodcritic。
vipin@laptop:~/chef-repo $ foodcritic ./cookbooks/<Cookbook Name> FC002: Avoid string interpolation where not required: ./cookbooks/ mysql/attributes/server.rb:220 ...TRUNCATED OUTPUT... FC024: Consider adding platform equivalents: ./cookbooks/<Cookbook Name>/ recipes/server.rb:132
步骤 2 – 生成详细报告。
vipin@laptop:~/chef-repo $ foodcritic -C ./cookbooks/mysql
cookbooks/<cookbook Name>/attributes/server.rb
FC002: Avoid string interpolation where not required
[...]
85| default['<Cookbook Name>']['conf_dir'] = "#{mysql['basedir']}"
[...]
cookbooks/<Cookbook Name>/recipes/client.rb
FC007: Ensure recipe dependencies are reflected in cookbook
metadata
40| end
41|when "mac_os_x"
42| include_recipe 'homebrew'
43|end
44|
工作方法
Foodcritic 定义了一组规则并检查配方代理，每个代理。它带有涉及各个领域的多个规则：样式、连通性、属性、字符串、概率、搜索、服务、文件、元数据等。
厨师 – ChefSpec
测试驱动开发 (TDD)是一种在编写任何实际配方代码之前编写单元测试的方法。测试应该是真实的，并且应该验证配方的作用。它实际上应该失败，因为没有开发配方。一旦开发了配方，测试就应该通过。
ChefSpec 建立在流行的 RSpec 框架之上，并为测试 Chef recipe 提供了定制的语法。
创建 ChefSpec
步骤 1 – 创建一个包含chefSpec gem 的gem 文件。
vipin@laptop:~/chef-repo $ subl Gemfile source 'https://rubygems.org' gem 'chefspec'
步骤 2 – 安装 gem。
vipin@laptop:~/chef-repo $ bundler install Fetching gem metadata from https://rubygems.org/ ...TRUNCATED OUTPUT... Installing chefspec (1.3.1) Using bundler (1.3.5) Your bundle is complete!
第 3 步– 创建一个规范目录。
vipin@laptop:~/chef-repo $ mkdir cookbooks/<Cookbook Name>/spec
第 4 步– 创建规范
vipin@laptop:~/chef-repo $ subl
cookbooks/my_cookbook/spec/default_spec.rb
require 'chefspec'
describe 'my_cookbook::default' do
let(:chef_run) {
ChefSpec::ChefRunner.new(
platform:'ubuntu', version:'12.04'
).converge(described_recipe)
}
it 'creates a greetings file, containing the platform
name' do
expect(chef_run).to
create_file_with_content('/tmp/greeting.txt','Hello! ubuntu!')
end
end
第 5 步– 验证 ChefSpec。
vipin@laptop:~/chef-repo $ rspec cookbooks/<Cookbook Name>/spec/default_spec.rb
F
Failures:
1) <CookBook Name> ::default creates a greetings file, containing the platform name
Failure/Error: expect(chef_run.converge(described_recipe)).to
create_file_with_content('/tmp/greeting.txt','Hello! ubuntu!')
File content:
does not match expected:
Hello! ubuntu!
# ./cookbooks/my_cookbook/spec/default_spec.rb:11:in `block
(2 levels) in <top (required)>'
Finished in 0.11152 seconds
1 example, 1 failure
Failed examples:
rspec ./cookbooks/my_cookbook/spec/default_spec.rb:10 # my_
cookbook::default creates a greetings file, containing the
platform name
第 6 步– 编辑 Cookbooks 默认配方。
vipin@laptop:~/chef-repo $ subl cookbooks/<Cookbook Name>/recipes/default.rb template '/tmp/greeting.txt' do variables greeting: 'Hello!' end
步骤 7 – 创建模板文件。
vipin@laptop:~/chef-repo $ subl cookbooks/< Cookbook Name>/recipes/default.rb <%= @greeting %> <%= node['platform'] %>!
步骤 8 – 再次运行 rspec。
vipin@laptop:~/chef-repo $ rspec cookbooks/<Cookbook Name>/spec/default_spec.rb . Finished in 0.10142 seconds 1 example, 0 failures
这个怎么运作
为了使其工作，我们需要首先设置基本基础设施，以便将 RSpec 与 Chef 结合使用。然后我们需要 ChefSpec Ruby gem 并且说明书需要一个名为 spec 的目录，所有测试都将在其中保存。
Chef – 使用 Test Kitchen 测试食谱
测试厨房是 Chef 的集成测试框架。它支持编写测试，这些测试在使用说明书实例化和聚合 VM 之后运行。测试在 VM 上运行，可以验证一切是否按预期工作。
这是 ChefSpec 的节点契约，它仅模拟 Chef 运行。Test Kitchen 启动一个真正的节点并在其上运行 Chef。
配置
为了做到这一点，我们需要在机器上安装 Vagrant，这有助于管理虚拟机。然后我们需要安装 bookshelf 并与 Vagrant 挂钩，以便管理食谱依赖项。
步骤 1 – 编辑食谱中的默认食谱。
vipin@laptop:~/chef-repo $ subl cookbooks/<Cookbook Name>/recipes/default.rb file "/tmp/greeting.txt" do content node['my_cookbook']['greeting'] end
第 2 步– 编辑食谱属性。
vipin@laptop:~/chef-repo $ subl cookbooks/<Cookbook Name>/attributes/default.rb default['my_cookbook']['greeting'] = "Ohai, Chefs!"
第 3 步– 编辑 gem 文件以安装必要的 Ruby gem。
vipin@laptop:~/chef-repo $ subl Gemfile gem 'test-kitchen', '~> 2.0.0.alpha.7' gem 'kitchen-vagrant'
第 4 步– 安装必要的 Ruby gem。
vipin@laptop:~/chef-repo $ bundle install ...TRUNCATED OUTPUT... Installing test-kitchen (1.0.0.alpha.7) Installing kitchen-vagrant (0.10.0) ...TRUNCATED OUTPUT...
第 5 步– 在说明书中创建 .kitchen.yml 文件。
vipin@laptop:~/chef-repo/cookbooks/my_cookbook $ subl .kitchen.yml
---
driver_plugin: vagrant
driver_config:
require_chef_omnibus: true
platforms:
- name: ubuntu-12.04
driver_config:
box: opscode-ubuntu-12.04
box_url:
https://opscode-vm.s3.amazonaws.com/vagrant/
opscode_ubuntu12.04_provisionerless.box
suites:
- name: default
run_list:
- recipe[minitest-handler]
- recipe[my_cookbook_test]
attributes: { my_cookbook: { greeting: 'Ohai, Minitest!'} }
第 6 步– 在说明书中创建一个测试目录。
vipin@laptop:~/chef-repo/cookbooks/<Cookbook Name>$ mkdir test
第 7 步– 创建用于集成测试的测试手册。
vipin@laptop:~/chef-repo/cookbooks/<Cookbook Name>/test $ knife cookbook create my_cookbook_test ** Creating cookbook my_cookbook_test ** Creating README for cookbook: my_cookbook_test ** Creating CHANGELOG for cookbook: my_cookbook_test ** Creating metadata for cookbook: my_cookbook_test
第 8 步– 编辑测试食谱默认配方。
vipin@laptop:~/chef-repo/cookbooks/my_cookbook $ subl test/cookbooks/my_cookbook_test/recipes/default.rb include_recipe 'my_cookbook::default'
第 9 步– 在食谱中创建 Minitest Spec。
vipin@laptop:~/chef-repo/cookbooks/my_cookbook $ mkdir -p
test/cookbooks/my_cookbook_test/files/default/tests/minitest
vipin@laptop:~/chef-repo/cookbooks/my_cookbook $ subl
test/cookbooks/my_cookbook_test/files/default/tests/minitest/default_test.rb
require 'minitest/spec'
describe_recipe 'my_cookbook::default' do
describe "greeting file" do
it "creates the greeting file" do
file("/tmp/greeting.txt").must_exist
end
it "contains what's stored in the 'greeting' node
attribute" do
file('/tmp/greeting.txt').must_include 'Ohai, Minitest!'
end
end
第 10 步– 编辑主食谱的 Berksfile。
vipin@laptop:~/chef-repo/cookbooks/my_cookbook $ subl Berksfile site :opscode metadata cookbook "apt" cookbook "minitest-handler" cookbook "my_cookbook_test", path: "./test/cookbooks/my_cookbook_test"
测试设置
vipin@laptop:~/chef-repo/cookbooks/my_cookbook $ kitchen test -----> Starting Kitchen (v1.0.0.alpha.7) ...TRUNCATED OUTPUT... -----> Converging <default-ubuntu-1204> -----> Installing Chef Omnibus (true) ...TRUNCATED OUTPUT... Starting Chef Client, version 11.4.4 [2013-06-29T18:33:57+00:00] INFO: *** Chef 11.4.4 *** [2013-06-29T18:33:58+00:00] INFO: Setting the run_list to ["recipe[minitest-handler]", "recipe[my_cookbook_test]"] from JSON ...TRUNCATED OUTPUT... # Running tests: recipe::my_cookbook::default::greeting file#test_0001_creates the greeting file = 0.00 s = . recipe::my_cookbook::default::greeting file#test_0002_contains what's stored in the 'greeting' node attribute = 0.00 s = . Finished tests in 0.011190s, 178.7277 tests/s, 178.7277 assertions/s. 2 tests, 2 assertions, 0 failures, 0 errors, 0 skips ...TRUNCATED OUTPUT... -----> Kitchen is finished. (2m5.69s)
厨师 – 节点
Knife preflight 会显示所有使用特定说明书的节点的详细信息，然后再将其上传到 Chef 服务器。
入门
为了开始，我们需要安装knife-preflight gem。
步骤 1 – 在 gem 文件中定义路径。
vipin@laptop:~/chef-repo $ subl Gemfile source 'https://rubygems.org' gem 'knife-preflight'
第 2 步– 运行 bundler 以安装 Knife-preflight gem。
vipin@laptop:~/chef-repo $ bundle install Fetching gem metadata from https://rubygems.org/ ...TRUNCATED OUTPUT... Installing knife-preflight (0.1.6)
工作方法
在给定的食谱上运行刀预检。
我们可以运行 preflight 命令来找出哪些节点和角色在其扩展的运行列表中具有给定的说明书。
vipin@laptop:~/chef-repo $ knife preflight ntp Searching for nodes containing ntp OR ntp::default in their expanded run_list... 2 Nodes found www-staging.example.com cms-staging.example.com Searching for roles containing ntp OR ntp::default in their expanded run_list... 3 Roles found your_cms_role your_www_role your_app_role Found 6 nodes and 3 roles using the specified search criteria
可以通过多种方式在节点上执行说明书。
-
您可以将说明书直接分配给节点，方法是将其添加到节点的运行列表中。
-
您可以向角色添加说明书并将角色添加到节点的运行列表中。
-
您可以将该角色添加到另一个角色的运行列表中，并将该其他角色添加到节点的运行列表中。
-
食谱可以是另一本使用过的食谱的依赖项。
无论说明书如何在节点的运行列表中结束，当 Chef 将所有扩展的角色和配方列表存储在节点属性中时，knife preflight 命令都会捕获它。Knife preflight 命令会准确地搜索这些节点属性。
Chef – Chef-Client 运行
为了测试 Chef-Client 运行，我们需要将 Chef-Client 配置为使用托管的 Chef 或自己的托管服务器。
在调试模式下运行 Chef-Client
vipin@server:~$ sudo chef-client -l debug
…TRUNCATED OUTPUT…
Hashed Path:A+WOcvvGu160cBO7IFKLYPhh9fI=
X-Ops-Content-Hash:2jmj7l5rSw0yVb/vlWAYkK/YBwk=
X-Ops-Timestamp:2012-12-27T11:14:07Z
X-Ops-UserId:vagrant'
Header hash: {"X-Ops-Sign"=>"algorithm=sha1;version=1.0;",
"X-Ops-Userid"=>"vagrant", "X-Ops-Timestamp"=>"2012-12-
27T11:14:07Z", "X-Ops-Content-
Hash"=>"2jmj7l5rSw0yVb/vlWAYkK/YBwk=", "X-Ops-
Authorization-
1"=>"HQmTt9U/
LJJVAJXWtyOu3GW8FbybxAIKp4rhiw9O9O3wtGYVHyVGuoilWDao",
"X-Ops-Authorization-
2"=>"2/uUBPWX+YAN0g1/
fD2854QAU2aUcnSaVM0cPNNrldoOocmA0U5HXkBJTKok",
"X-Ops-Authorization-
3"=>"6EXPrEJg5T+
ddWd5qHAN6zMqYc3untb41t+eBpigGHPhtn1LLInMkPeIYwBm",
"X-Ops-Authorization-
4"=>"B0Fwbwz2HVP3wEsYdBGu7yOatq7fZBXHfIpeOi0kn/
Vn0P7HrucnOpONmMgU", "X-Ops-Authorization-
5"=>"RBmmbetFSKCYsdg2v2mW/
ifLIVemhsHyOQjffPYPpNIB3U2n7vji37NxRnBY",
"X-Ops-Authorization-
6"=>"Pb3VM7FmY60xKvWfZyahM8y8WVV9xPWsD1vngihjFw=="}
[2012-12-27T11:14:07+00:00] DEBUG: Sending HTTP Request via
GET to api.opscode.com:443/organizations/agilewebops/
nodes/vagrant
[2012-12-27T11:14:09+00:00] DEBUG: ---- HTTP Status and
Header Data: ----
[2012-12-27T11:14:09+00:00] DEBUG: HTTP 1.1 200 OK
[2012-12-27T11:14:09+00:00] DEBUG: server: nginx/1.0.5
[2012-12-27T11:14:09+00:00] DEBUG: date: Thu, 27 Dec 2012
检查上次 Chef-Client 运行的结果
为了检查上一次 Chef-Client 运行，尤其是在我们开发新食谱时的失败问题，我们需要知道到底出了什么问题。尽管 Chef 在标准输出中打印了所有内容，但人们可能希望再次查看调试日志。
如果我们想进行测试，我们需要有一本编译失败的损坏的食谱。
user@server:~$ sudo chef-client
==================================================================
==============
Recipe Compile Error in /srv/chef/file_store/cookbooks/my_
cookbook/recipes/default.rb
==================================================================
==============
NoMethodError
-------------
undefined method `each' for nil:NilClass
Cookbook Trace:
---------------
/srv/chef/file_store/cookbooks/my_cookbook/recipes/default.
rb:9:in `from_file'
Relevant File Content:
----------------------
/srv/chef/file_store/cookbooks/my_cookbook/recipes/default.rb:
2: # Cookbook Name:: my_cookbook
3: # Recipe:: default
4: #
5: # Copyright 2013, YOUR_COMPANY_NAME
6: #
7: # All rights reserved - Do Not Redistribute
8: #
9&Gt nil.each {}
10:
有关更多详细信息，我们可以查看堆栈跟踪。
user@server:~$ less /srv/chef/file_store/chef-stacktrace.out Generated at 2013-07-21 18:34:05 +0000 NoMethodError: undefined method `each' for nil:NilClass /srv/chef/file_store/cookbooks/my_cookbook/recipes/default.rb:9:in `from_file' /opt/chef/embedded/lib/ruby/gems/1.9.1/gems/chef-11.4.4/lib/chef/ mixin/from_file.rb:30:in `instance_eval' /opt/chef/embedded/lib/ruby/gems/1.9.1/gems/chef-11.4.4/lib/chef/ mixin/from_file.rb:30:in `from_file' /opt/chef/embedded/lib/ruby/gems/1.9.1/gems/chef-11.4.4/lib/chef/ cookbook_version.rb:346:in `load_recipe'
Chef – 动态配置食谱
属性是动态配置说明书的关键组件。属性使作者能够使食谱可配置。通过覆盖食谱中设置的默认值，用户可以注入自己的值。
步骤 1 – 为说明书属性创建一个默认文件并为其添加一个默认属性。
vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/attributes/default.rb default['my_cookbook']['message'] = 'hello world!'
步骤 2 – 定义配方内的属性。
vipin@laptop:~/chef-repo $ subl cookbooks/<Cookbook Name>/recipes/default.rb
message = node['my_cookbook']['message']
Chef::Log.info("** Saying what I was told to say: #{message}")
第 3 步– 上传修改后的食谱。
vipin@laptop:~/chef-repo $ knife cookbook upload my_cookbook Uploading my_cookbook [0.1.0]
第 4 步– 运行定义节点的 Chef-Client。
user@server:~$ sudo chef-client ...TRUNCATED OUTPUT... [2013-01-13T20:48:21+00:00] INFO: ** Saying what I was told to say: hello world! ...TRUNCATED OUTPUT...
工作方法
Chef 在执行之前从属性文件中加载所有属性。属性与节点对象一起存储。可以访问与配方中的节点对象一起存储的所有属性并检索它们的当前值。
Chef 有一个受限制的结构，从默认的最低开始，然后是正常的（与集合别名），然后覆盖。配方中设置的属性级别优先于属性文件中设置的相同级别。
在节点和环境级别覆盖属性
在角色或环境中定义的属性具有最高优先级。
步骤 1 – 创建一个角色。
vipin@laptop:~/chef-repo $ subl roles/german_hosts.rb
name "german_hosts"
description "This Role contains hosts, which should print out
their messages in German"
run_list "recipe[my_cookbook]"
default_attributes "my_cookbook" => { "message" => "Hallo Welt!" }
第 2 步– 将角色上传到 Chef 服务器。
vipin@laptop:~/chef-repo $ knife role from file german_hosts.rb Updated Role german_hosts!
步骤 3 – 将角色分配给节点。
vipin@laptop:~/chef-repo $ knife node edit server "run_list": [ "role[german_hosts]" ] Saving updated run_list on node server
第 4 步– 运行 Chef-Client。
user@server:~$ sudo chef-client ...TRUNCATED OUTPUT... [2013-01-13T20:49:49+00:00] INFO: ** Saying what I was told to say: Hallo Welt! ...TRUNCATED OUTPUT...
厨师 – 模板
在基础设施中，配置管理是关于如何配置主机。一般来说，所有的配置都是使用配置文件完成的。Chef 使用模板来用动态值填充配置文件。
Chef 提供模板作为可在配方中使用的资源。配置文件的动态值可以从数据包、属性中检索，甚至可以通过将它们传递到模板中来计算它们。
如何使用它？
步骤 1 – 将模板添加到配方中。
vipin@laptop:~/chef-repo $ subl cookbooks/<Cookbook Name>/recipes/default.rb
template '/tmp/message' do
source 'Test.erb'
variables(
hi: 'Tesing',
world: 'Welt',
from: node['fqdn']
)
end
步骤 2 – 添加ERB模板文件。
vipin@laptop:~/chef-repo $ subl cookbooks/<Cookbook Name>/templates/default/test.erb <%- 4.times do %> <%= @hi %>, <%= @world %> from <%= @from %>! <%- end %>
第 3 步– 将修改后的食谱上传到 Chef 服务器。
vipin@laptop:~/chef-repo $ knife cookbook upload <Cookbook Name> Uploading my_cookbook [0.1.0] Run Chef Client on your node: user@server:~$ sudo chef-client ...TRUNCATED OUTPUT... [2017-01-14T20:41:21+00:00] INFO: Processing template[/tmp/ message] action create (my_cookbook::default line 9) [2017-01-14T20:41:22+00:00] INFO: template[/tmp/message] updated content
步骤 4 – 验证上传文件的内容。
user@server:~$ sudo cat /tmp/message Hallo, Welt from vagrant.vm! Hallo, Welt from vagrant.vm! Hallo, Welt from vagrant.vm! Hallo, Welt from vagrant.vm!
工作流程
Chef 使用 Erubis 作为其模板语言。它允许在模板的特殊符号中嵌入纯 Ruby 代码。
-
<%= %> 用于将变量或 Ruby 表达式的值打印到生成的文件中。
-
<%- %> 用于将 Ruby 逻辑嵌入到模板文件中。我们用它来循环我们的表达式四次。
Chef – 带有 Chef DSL 的普通 Ruby
在 Chef 中，如果需要创建简单的配方，可以使用 Chef 中可用的资源，例如模板、remote_file 和服务。然而，随着配方变得复杂，人们需要高级技术，例如条件语句以在条件下执行部分配方。这就是将普通 Ruby 与 Chef 领域特定语言 (DSL) 相结合的强大之处。
如何使用它？
在客户端模式下的任何节点上启动 Chef Shell，以便能够访问 Chef 服务器。
user@server:~$ sudo chef-shell --client loading configuration: /etc/chef/client.rb Session type: client ...TRUNCATED OUTPUT... run `help' for help, `exit' or ^D to quit. Ohai2u user@server! Chef>
Chef DSL 的基本条件
使用普通 Ruby 按名称对节点进行排序。
chef > nodes.sort! {|a,b| a.name <=> b.name }
=> [node[alice],node[server]]
循环遍历节点，打印它们的操作系统。
chef > nodes.each do |n| chef > puts n['os'] chef ?> end linux windows => [node[server], node[alice]]
使用数组、循环和字符串扩展来安装多个 Ruby gem 以构建 gem 名称。
chef > %w{ec2 essentials}.each do |gem|
chef > gem_package "knife-#{gem}"
chef ?> end => ["ec2", "essentials"]
工作方法
Chef 配方是 Ruby 文件，在 Chef 运行的上下文中对其进行评估。它们可以包含简单的 Ruby 代码，例如 if 语句和循环以及 Chef DSL 元素（例如资源）。
在配方中，您可以简单地声明 Ruby 变量并为其赋值。
厨师 – 带有食谱的红宝石宝石
食谱是食谱的关键构建块，它基本上是 Ruby 代码。可以在 Chef 配方中使用所有 Ruby 语言功能。大多数情况下，Ruby 内置功能就足够了，但有时可能需要使用额外的 Ruby gem。例如，如果需要从配方本身访问 MySQL 数据库。
Chef recipe 能够获取所需的 Ruby gem，以便在相同的 recipe 中使用它们。
在给定的配方中使用 iptable Gem
步骤 1 – 编辑食谱的默认配方并安装要在配方中使用的 gem。
vipin@laptop:~/chef-repo $ subl
cookbooks/my_cookbook/recipes/default.rb
chef_gem 'ipaddress'
require 'ipaddress'
ip = IPAddress("192.168.0.1/24")
Chef::Log.info("Netmask of #{ip}: #{ip.netmask}")
第 2 步– 将修改后的食谱上传到 Chef 服务器。
vipin@laptop:~/chef-repo $ knife cookbook upload my_cookbook Uploading my_cookbook [0.1.0]
第 3 步– 运行 Chef 客户端以查看输出。
user@server $ sudo chef-client ...TRUNCATED OUTPUT... [2013-01-18T14:02:02+00:00] INFO: Netmask of 192.168.0.1: 255.255.255.0 ...TRUNCATED OUTPUT...
工作方法
Chef 运行步骤包括编译阶段和执行阶段，其中编译所有资源，执行阶段 Chef 运行资源提供程序以将节点收敛到所需状态。如果需要在说明书中使用任何特定的 Ruby gem，则需要在复杂化阶段安装 gem。
Chef_gem 资源将完全相同，在 Chef 中，Omnibus 是唯一的工作方式。它的主要功能是让 Chef 可以使用 gem。
厨师 – 图书馆
Chef 中的库提供了一个封装编译逻辑的地方，以便食谱食谱保持整洁。
创建库
第 1 步– 在食谱库中创建一个辅助方法。
vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/libraries/ipaddress.rb class Chef::Recipe def netmask(ipaddress) IPAddress(ipaddress).netmask end end
步骤 2 – 使用辅助方法。
vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/recipes/default.rb
ip = '10.10.0.0/24'
mask = netmask(ip) # here we use the library method
Chef::Log.info("Netmask of #{ip}: #{mask}")
第 3 步– 将修改后的食谱上传到 Chef 服务器。
vipin@laptop:~/chef-repo $ knife cookbook upload my_cookbook Uploading my_cookbook [0.1.0]
测试库
user@server $ sudo chef-client ...TRUNCATED OUTPUT... [2013-01-18T14:38:26+00:00] INFO: Netmask of 10.10.0.0/24: 255.255.255.0 ...TRUNCATED OUTPUT...
工作方法
Chef 库代码可以打开chef::Recipe 类并添加新方法，如步骤1 中所做的那样。这一步不是最干净但最简单的方法。
class Chef::Recipe def netmask(ipaddress) ... end end
最佳实践
一旦我们打开了 Chef::recipe 类，它就会被污染。作为最佳实践，在库中引入新的子类并将方法定义为类方法总是更好的方法。这避免了拉取chef::recipe 命名空间。
vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/libraries/ipaddress.rb class Chef::Recipe::IPAddress def self.netmask(ipaddress) IPAddress(ipaddress).netmask end end
我们可以使用配方中的方法，如
IPAddress.netmask(ip)
厨师 – 定义
定义可以定义为一种对资源进行分组的逻辑方法，这些资源会被反复使用。在此流程中，我们对资源进行分组并为其命名，以重新获得定义好的说明书的可读性。
为了做到这一点，我们应该有一个食谱。在这种情况下，我们使用 test_cookbook 和节点的运行列表，其中包括食谱。
创建定义
步骤 1 – 在说明书定义文件夹中创建一个新的定义文件。
vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/definitions/
capistrano_deploy_dirs.rb
define :capistrano_deploy_dirs, :deploy_to => '' do
directory "#{params[:deploy_to]}/releases"
directory "#{params[:deploy_to]}/shared"
directory "#{params[:deploy_to]}/shared/system"
end
第 2 步– 在食谱默认配方中使用定义。
vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb capistrano_deploy_dirs do deploy_to "/srv" end
第 3 步– 将食谱上传到厨师服务器。
vipin@laptop:~/chef-repo $ knife cookbook upload test_cookbook Uploading test_cookbook [0.1.0]
第 4 步– 在所需节点上运行 Chef 客户端。
vipin@laptop:~/chef-repuser@server $ sudo chef-client ...TRUNCATED OUTPUT... [2013-01-18T16:31:11+00:00] INFO: Processing directory[/srv/ releases] action create (my_cookbook::default line 2) [2013-01-18T16:31:11+00:00] INFO: directory[/srv/releases] created directory /srv/releases [2013-01-18T16:31:11+00:00] INFO: Processing directory[/srv/ shared] action create (my_cookbook::default line 3) [2013-01-18T16:31:11+00:00] INFO: directory[/srv/shared] created directory /srv/shared [2013-01-18T16:31:11+00:00] INFO: Processing directory[/srv/ shared/system] action create (my_cookbook::default line 4) [2013-01-18T16:31:11+00:00] INFO: directory[/srv/shared/system]
食谱中的定义就像微型，它将资源分组并为其命名。定义有一个名称，通过它可以告诉他们可以在配方中调用哪个，并且它有一个周长列表。
在定义中，我们的代码中有如下所示的参数。
…..
directory "#{params[:deploy_to]}/releases"
directory "#{params[:deploy_to]}/shared"
directory "#{params[:deploy_to]}/shared/system”
……
它可以在默认配方中使用，如下所示。
capistrano_deploy_dirs do deploy_to "/srv"` end
Chef – 环境变量
环境变量是让 Chef recipe 在任何特定节点上成功运行的关键方法。有多种方法可以做到这一点，手动设置它们或使用 Shell 脚本。通过配方设置它们是我们需要在这里执行的操作。
为此，我们需要有一个食谱，我们将使用 test_cookbook 和一个包含 test_cookbook 的运行列表。
使用 Chef Recipe 设置环境变量
步骤 1 – 使用环境变量更新食谱的默认配方。
vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb ENV['MESSAGE'] = 'Testing environment variable update with chef !' execute 'print value of environment variable $MESSAGE' do command 'echo $MESSAGE > /tmp/message' end
第 2 步– 将更新的食谱上传到服务器。
vipin@laptop:~/chef-repo $ knife cookbook upload test_cookbook Uploading my_cookbook [0.1.0]
第 3 步– 运行 Chef 客户端以创建临时文件。
user@server:~$ sudo chef-client ...TRUNCATED OUTPUT... [2013-01-25T15:01:57+00:00] INFO: Processing execute[print value of environment variable $MESSAGE] action run (my_cookbook::default line 11) [2013-01-25T15:01:57+00:00] INFO: execute[print value of environment variable $MESSAGE] ran successfully ...TRUNCATED OUTPUT...
验证变量
user@server:~$ cat /tmp/message Hello from Chef
工作方法
Ruby 通过 ENV 公开当前环境变量——一个哈希来读取和修改环境变量。
执行资源
我们可以使用 execute 资源在食谱的 Chef 默认配方中执行相同的操作。
mma@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb execute 'print value of environment variable $MESSAGE' do command 'echo $MESSAGE > /tmp/message' environment 'MESSAGE' => 'Hello from the execute resource' end
注意– 使用 ENV 设置环境变量将使该变量在整个 Chef 运行期间可用。相比之下，将其传递给执行资源只会使其可用于资源执行的那个命令。
Chef – 数据错误
Chef 数据包可以定义为可以与食谱一起使用的任意数据集合。当人们不想在食谱中硬编码属性或在食谱中存储属性时，使用数据包非常有用。
工作方法
在以下设置中，我们尝试与 http 端点 URL 通信。为此，我们需要创建一个数据包，它将保存端点 URL 详细信息并在我们的配方中使用它。
步骤 1 – 为我们的数据包创建一个目录。
mma@laptop:~/chef-repo $ mkdir data_bags/hooks
步骤 2 – 为请求箱创建一个数据包项目。需要确保使用的是定义好的 requestBin URL。
vipi@laptop:~/chef-repo $ subl data_bags/hooks/request_bin.json {
"id": "request_bin",
"url": "http://requestb.in/1abd0kf1"
}
第 3 步– 在 Chef 服务器上创建一个数据包
vipin@laptop:~/chef-repo $ knife data bag create hooks Created data_bag[hooks]
第 4 步– 将数据包上传到 Chef 服务器。
vipin@laptop:~/chef-repo $ knife data bag from file hooks requestbin.json Updated data_bag_item[hooks::RequestBin]
第 5 步– 更新食谱的默认食谱以从数据包中接收所需的食谱。
vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/recipes/default.rb
hook = data_bag_item('hooks', 'request_bin')
http_request 'callback' do
url hook['url']
end
第 6 步– 将修改后的食谱上传到 Chef 服务器。
vipin@laptop:~/chef-repo $ knife cookbook upload my_cookbook Uploading my_cookbook [0.1.0]
第 7 步– 在节点上运行 Chef 客户端以检查 http 请求 bin 是否被执行。
user@server:~$ sudo chef-client ...TRUNCATED OUTPUT... [2013-02-22T20:37:35+00:00] INFO: http_request[callback] GET to http://requestb.in/1abd0kf1 successful ...TRUNCATED OUTPUT...
这个怎么运作
数据包是结构数据条目的命名集合。需要定义数据入口并调用JSON文件中的数据包项。还可以从配方中搜索数据包项目以使用存储在数据包中的数据。
我们创建了一个名为 hooks 的数据包。数据包是 Chef 存储库中的一个目录。我们使用 Knife 在服务器上创建它。
Chef – 数据错误脚本
在某些情况下，不可能将服务器置于 Chef 的完全控制之下。在这种情况下，人们可能需要从脚本访问 Chef 数据包中的值。为此，需要将数据包值存储在 JSON 文件中，并让添加的脚本访问这些值。
为此，一个人需要有一本食谱。在我们的例子中，我们将像之前一样使用 test_cookbook 并且应该有节点的运行列表，其中包括 test_cookbook 定义。
工作方法
步骤 1 – 创建一个数据包。
vipin@laptop:~/chef-repo $ mkdir data_bags/servers vipin@laptop:~/chef-repo $ knife data bag create servers Created data_bag[servers]
第 2 步– 创建一个数据包项目。
vipin@laptop:~/chef-repo $ subl data_bags/servers/Storage.json {
"id": "storage",
"host": "10.0.0.12"
}
步骤 3 – 更新数据包项目。
vipin@laptop:~/chef-repo $ subl data_bags/servers/Storage.json {
"id": "storage",
"host": "10.0.0.12"
}
在食谱中使用
步骤 1 – 需要使用上述说明书创建一个包含数据包值的 JSON 文件，以便外部脚本可以访问这些值。
vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb
file "/etc/backup_config.json" do
owner "root"
group "root"
mode 0644
content data_bag_item('servers', 'backup')['host'].to_json
end
第 2 步– 将 test_cookbook 上传到 Chef 服务器。
vipin@laptop:~/chef-repo $ knife cookbook upload test_cookbook Uploading my_cookbook [0.1.0]
第 3 步– 在节点上运行 Chef 客户端。
user@server:~$ sudo chef-client ...TRUNCATED OUTPUT... [2013-03-14T20:30:33+00:00] INFO: Processing file[/etc/backup_config.json] action create (my_cookbook::default line 9) [2013-03-14T20:30:34+00:00] INFO: entered create [2013-03-14T20:30:34+00:00] INFO: file[/etc/backup_config.json] owner changed to 0 [2013-03-14T20:30:34+00:00] INFO: file[/etc/backup_config.json] group changed to 0 [2013-03-14T20:30:34+00:00] INFO: file[/etc/backup_config.json] mode changed to 644 [2013-03-14T20:30:34+00:00] INFO: file[/etc/backup_config.json] created file /etc/backup_config.json ...TRUNCATED OUTPUT...
第 4 步– 验证生成的 JSON 文件的内容。
user@server:~$ cat /etc/backup_config.json "10.0.0.12"
脚本工作流程
在上面的命令中，我们使用的在/etc目录中创建 JSON 文件的文件资源是在默认说明书中定义的。它使用 data_bag_item 方法直接从数据包中获取文件内容。我们从数据包项目访问主机值并将其转换为 JSON。文件资源使用 JSON 转换的值作为其内容并将其写入磁盘。
Chef – 烹饪书的跨平台
跨平台说明书是那些采用将要运行的底层环境的说明书。Chef 提供了许多功能，有助于编写能够在任何操作系统上运行的跨平台食谱，并将在其上部署。这有助于开发人员编写完全可操作的食谱。
为了做到这一点，我们需要有一本食谱。在我们的例子中，它将是 test_cookbook 和一个包含食谱定义的运行列表。
工作方法
检索节点平台详细信息并执行我们食谱中的条件逻辑取决于平台。在我们的例子中，我们将在 Ubuntu 上测试它。
步骤 1 – 如果节点是 Ubuntu，则记录一条消息。
vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb
Log.info("Running on ubuntu") if node.platform['ubuntu']
第 2 步– 将食谱上传到 Chef 服务器。
vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb Uploading my_cookbook [0.1.0] Uploaded 1 cookbook.
第 3 步– 在节点上运行 Chef 客户端。
user@server:~$ sudo chef-client ...TRUNCATED OUTPUT... [2013-03-03T20:07:39+00:00] INFO: Running on Ubuntu ...TRUNCATED OUTPUT...
或者，如果对特定平台不感兴趣，而只需要知道使用的是哪个声明式，则可以使用以下语句。
Log.info("Running on a debian derivative") if
platform_family?('debian')
上传修改后的说明书并在 Ubuntu 节点上运行 Chef 客户端将显示以下结果。
[2013-03-03T20:16:14+00:00] INFO: Running on a debian derivative
脚本工作流程
在上面的命令中，Ohai 将发现节点操作系统的当前状态，并将其作为平台属性与节点对象一起存储。
node['platform']
或者，您可以使用方法样式语法 –
node.platform
设置平台特定值
为了设置特定于平台的值，chef 提供了方便的方法 value_for_platform 和 value_for_platform_family。它们可用于避免复杂的 case 语句并使用简单的散列代替。
示例食谱
execute "start-runsvdir" do
command value_for_platform(
"debian" => { "default" => "runsvdir-start" },
"ubuntu" => { "default" => "start runsvdir" },
"gentoo" => { "default" => "/etc/init.d/runit-start start" }
)
action :nothing
end
在上面的示例中，命令是特定于操作系统的定义。
- 对于 Debian，“runsvdir-start”将起作用
- 对于 Ubuntu，“start runningvdir”将起作用
- 对于 Gentoo，”/etc/init.d/runit-start” 将起作用
厨师 – 资源
Chef 资源代表处于其所需状态的操作系统的一部分。它是一种配置策略声明，它描述了希望使用资源提供者将当前配置带到的节点的期望状态。它有助于使用 Chef 的 Ohai 机制了解目标机器的当前状态。它还有助于定义使目标机器达到该状态所需执行的步骤。资源分组在描述工作配置的配方中。
在 Chef 的情况下，chef::Platform 映射每个节点的提供者和平台版本。在每次 Chef-client 运行开始时，Chef 服务器会收集任何机器当前状态的详细信息。稍后，Chef 服务器使用这些值来识别正确的提供者。
资源语法
type 'name' do attribute 'value' action :type_of_action end
在上面的语法中，’type’ 是资源类型，’name’ 是我们将要使用的名称。在“do”和“end”块中，我们拥有该资源的属性以及我们需要对该特定资源采取的操作。
我们在配方中使用的每个资源都有自己的一组动作，这些动作在 ‘do’ 和 ‘end’ 块中定义。
例子
type 'name' do attribute 'value' action :type_of_action end
所有资源共享一组通用的功能、操作、属性、条件执行、通知和相关的操作路径。
| Actions | 的：没有什么动作可以与任何资源或自定义资源使用。 |
| Properties | ignore_failure、provider、retries、retry_delay 和 support 属性可用于任何资源或自定义资源。 |
| Guards | not_if 和 only_if 条件执行可用于在某些资源周围放置额外的保护，以便它们仅在满足条件时运行。 |
| Guard Interpreters | 使用基于脚本的资源评估字符串命令：bash、csh、perl、powershell_script、python或ruby。 |
| Notifications | 通知和订阅通知可用于任何资源。 |
| Relative Paths | #{ENV[‘HOME’]} 相对路径可用于任何资源。 |
| Windows File Security | 该模板文件，remote_file，cookbook_file，目录和remote_directory资源支持的食谱中使用继承和访问控制列表（ACL）的。 |
| Run in Compile Phase | 有时需要在所有其他资源之前或在所有资源添加到资源集合之后运行资源。 |
可用资源
apt_package
使用apt_package资源管理 Debian 和 Ubuntu 平台的软件包。
重击
使用bash资源通过 Bash 解释器执行脚本。此资源还可以使用可执行资源可用的任何操作和属性。使用此资源执行的命令（就其性质而言）不是幂等的，因为它们通常是运行它们的环境所独有的。使用 not_if 和 only_if 来保护此资源的幂等性。
批
使用批处理资源通过 cmd.exe 解释器执行批处理脚本。该批次的资源创建并执行一个临时文件（类似于如何脚本资源的行为），而不是运行命令行内。
从和属性（创建，CWD，环境，组，路径，超时和用户），该资源继承操作（：什么：跑）执行资源。使用此资源执行的命令（就其性质而言）不是幂等的，因为它们通常是运行它们的环境所独有的。使用not_if和only_if来保护此资源的幂等性。
bff_package
使用bff_package资源通过installp实用程序管理 AIX 平台的包。从本地文件安装包时，必须使用remote_file或cookbook_file 资源将其添加到节点。
厨师宝石
使用chef_gem资源仅为专用于Chef-Client 的Ruby 实例安装gem。从本地文件安装 gem 时，必须使用remote_file或cookbook_file资源将其添加到节点。
该chef_gem资源与所有相同的属性和选项的作品gem_package资源，但不接受gem_binary属性，因为它总是使用厨师客户端在其下运行的CurrentGemEnvironment。除了执行类似于gem_package资源的操作之外，chef_gem资源还执行上述操作。
食谱文件
使用cookbook_file资源将文件从COOKBOOK_NAME/files/ 的子目录传输到位于运行ChefClient 的主机上的指定路径。
该文件是根据文件特性选择的，这允许基于主机名、主机平台（操作系统、发行版或适当的）或平台版本使用不同的源文件。位于 COOKBOOK_NAME/files/default 子目录中的文件可以在任何平台上使用。
定时任务
使用 cron 资源来管理基于时间的作业调度的 cron 条目。如果未提供，计划的属性将默认为 &ast。cron 资源需要访问 crontab 程序，通常是 cron。
Csh
使用 csh 资源通过 csh 解释器执行脚本。此资源还可以使用可执行资源可用的任何操作和属性。
使用此资源执行的命令（就其性质而言）不是幂等的，因为它们通常是运行它们的环境所独有的。使用 not_if 和 only_if 来保护此资源的幂等性。
部署
使用部署资源来管理和控制部署。这是一种流行的资源，但也很复杂，具有最多的属性、多个提供程序、回调的增加的复杂性，以及支持从配方内修改布局的四个属性。
目录
使用目录资源来管理目录，这是一个文件夹层次结构，包含存储在计算机上的所有信息。根目录是顶级目录，在该目录下组织目录的其余部分。
该目录资源使用的名称属性来指定目录中的一个位置的路径。通常，需要访问目录中该位置的权限。
dpkg_package
使用dpkg_package资源来管理dpkg平台的包。从本地文件安装包时，必须使用remote_file或cookbook_file资源将其添加到节点。
easy_install_package
使用easy_install_package资源管理 Python 平台的包。
环境
使用env资源管理 Microsoft Windows 中的环境密钥。设置环境密钥后，必须重新启动 Microsoft Windows，然后任务计划程序才能使用环境密钥。
erl_call
使用erl_call资源连接到位于分布式 Erlang 系统中的节点。使用此资源执行的命令（就其性质而言）不是幂等的，因为它们通常是运行它们的环境所独有的。使用 not_if 和 only_if 来保护此资源的幂等性。
执行
使用execute资源执行单个命令。使用此资源执行的命令（就其性质而言）不是幂等的，因为它们通常是运行它们的环境所独有的。使用not_if和only_if来保护此资源的幂等性。
文件
使用文件资源直接在节点上管理文件。
freebsd_package
使用freebsd_package资源来管理 FreeBSD 平台的包。
gem_package
使用gem_package资源来管理只包含在配方中的 gem 包。从本地文件安装包时，必须使用remote_file或cookbook_file资源将其添加到节点。
吉特
使用git资源管理存在于 git 存储库中的源代码控制资源。使用 git 资源中的所有功能需要 git 版本 1.6.5（或更高版本）。
团体
使用组资源来管理本地组。
homebrew_package
使用homebrew_package资源管理 Mac OS X 平台的包。
http_request
使用http_request资源发送带有任意消息的 HTTP 请求（GET、PUT、POST、DELETE、HEAD 或 OPTIONS）。当需要自定义回调时，此资源通常很有用。
如果配置
使用ifconfig资源来管理接口。
ips_package
使用ips_package资源在 Solaris 11 平台上管理软件包（使用映像包管理系统 (IPS)）。
克什
使用ksh资源通过 Korn shell (ksh) 解释器执行脚本。此资源还可以使用可执行资源可用的任何操作和属性。
使用此资源执行的命令（就其性质而言）不是幂等的，因为它们通常是运行它们的环境所独有的。使用 not_if 和 only_if 来保护此资源的幂等性。
关联
使用链接资源创建符号或硬链接。
日志
使用日志资源创建日志条目。日志资源的行为与任何其他资源一样：在编译阶段构建到资源集合中，然后在执行阶段运行。（要创建未内置到资源集合中的日志条目，请使用 Chef::Log 而不是日志资源）
macports_package
使用 macports_package 资源来管理 Mac OS X 平台的包。
妈妈
使用mdadm资源通过 mdadm 实用程序在 Linux 环境中管理 RAID 设备。mdadm 提供程序将创建和组装一个阵列，但它不会创建用于在重新启动时保留阵列的配置文件。
如果需要配置文件，则必须通过指定具有正确阵列布局的模板，然后使用挂载提供程序创建文件系统表 (fstab) 条目来完成。
山
使用挂载资源来管理挂载的文件系统。
奥海
使用ohai资源在节点上重新加载 Ohai 配置。这允许更改系统属性的食谱（如添加用户的食谱）稍后在厨师客户端运行期间引用这些属性。
包裹
使用包资源来管理包。从本地文件（例如使用 RubyGems、dpkg 或 RPM 包管理器）安装包时，必须使用 remote_file 或 cookbook_file 资源将该文件添加到节点。
pacman_package
使用pacman_package资源在 Arch Linux 平台上管理包（使用 pacman）。
powershell_script
使用powershell_script资源通过 Windows PowerShell 解释器执行脚本，这与使用脚本和基于脚本的资源（bash、csh、perl、python 和 ruby）的方式非常相似。powershell_script 特定于 Microsoft Windows 平台和 Windows PowerShell 解释器。
Python
使用python资源通过 Python 解释器执行脚本。此资源还可以使用可执行资源可用的任何操作和属性。
使用此资源执行的命令（就其性质而言）不是幂等的，因为它们通常是运行它们的环境所独有的。使用 not_if 和 only_if 来保护此资源的幂等性。
重启
使用重新启动资源重新启动节点，这是在某些平台上进行某些安装的必要步骤。此资源支持在 Microsoft Windows、Mac OS X 和 Linux 平台上使用。
注册表键
使用registry_key资源在 Microsoft Windows 中创建和删除注册表项。
远程目录
使用remote_directory资源将目录从说明书增量传输到节点。从说明书复制的目录应位于 COOKBOOK_NAME/files/default/REMOTE_DIRECTORY 下。
remote_directory 资源将遵守文件特异性。
远程文件
使用remote_file资源通过文件特异性从远程位置传输文件。此资源类似于文件资源。
路线
Linux环境下使用路由资源管理系统路由表。
rpm_package
使用rpm_package资源来管理 RPM 包管理器平台的包。
红宝石
使用ruby资源通过 Ruby 解释器执行脚本。此资源还可以使用可执行资源可用的任何操作和属性。
使用此资源执行的命令（就其性质而言）不是幂等的，因为它们通常是运行它们的环境所独有的。使用 not_if 和 only_if 来保护此资源的幂等性。
ruby_block
使用ruby_block资源在 Chef-Client 运行期间执行 Ruby 代码。ruby_block 资源中的 Ruby 代码在收敛期间与其他资源一起评估，而 ruby_block 资源之外的 Ruby 代码在其他资源之前评估，因为配方被编译。
脚本
使用脚本资源通过指定的解释器（例如 Bash、csh、Perl、Python 或 Ruby）执行脚本。此资源还可以使用可执行资源可用的任何操作和属性。
使用此资源执行的命令（就其性质而言）不是幂等的，因为它们通常是运行它们的环境所独有的。使用 not_if 和 only_if 来保护此资源的幂等性。
服务
使用服务资源来管理服务。
smart_os_package
使用smartos_package资源管理 SmartOS 平台的包。
solaris_package
该solaris_package资源被用于管理Solaris平台的软件包。
颠覆
使用subversion资源来管理存在于 Subversion 存储库中的源代码控制资源。
模板
通过将文件从 COOKBOOK_NAME/templates/ 的子目录传输到运行 Chef-Client 的主机上的指定路径，使用模板资源来管理使用嵌入式 Ruby (ERB) 模板的文件的内容。此资源包括来自文件资源的操作和属性。模板资源管理的模板文件遵循与 remote_file 和文件资源相同的文件特性规则。
用户
使用用户资源添加用户、更新现有用户、删除用户以及锁定/解锁用户密码。
windows_package
使用windows_package资源管理 Microsoft Windows 平台的 Microsoft 安装程序包 (MSI) 包。
windows_service
使用windows_service资源管理 Microsoft Windows 平台上的服务。
yum_package
使用yum_package资源为 Red Hat 和 CentOS 平台安装、升级和删除带有 Yum 的软件包。yum_package 资源能够解析包的数据，就像 Yum 从命令行运行时所做的那样。这允许有多种安装包的选项，例如最低版本、虚拟提供和库名称。
Chef – 轻量级资源提供者
轻量级资源提供程序 (LWRP)提供了一个选项，通过扩展其功能来扩展可用资源列表，并允许 Chef 用户创建自定义资源。
通过创建自定义资源，您可以简单地编写食谱，因为您可以使用 Chef DSL 拥有丰富的自定义资源，这有助于使食谱代码更具表现力。
在 Chef 社区中，许多自定义资源是使用 LWRP 实现的。有许多 LWRP 的工作示例，例如iptables_rules和apt_repository。
工作方法
确保有说明书名称 Testing_resource 和包含 Testing_resource 说明书的节点的 run_list。
建筑LWRP
步骤 1 – 在 Testing_resource 说明书中创建自定义资源。
vipin@laptop:~/chef-repo $ subl cookbooks/Testing_resource/resources/default.rb actions :create, :remove attribute :title, kind_of: String, default: "World" attribute :path, kind_of: String, default: "/tmp/greeting.txt"
第 2 步– 在 Tesing_resource 说明书中为资源创建一个提供者。
vipin@laptop:~/chef-repo $ subl cookbooks/Testing_resource/provider/default.rb
action :create do
log "Adding '#{new_resource.name}' greeting as #{new_resource.
path}"
file new_resource.path do
content "#{new_resource.name}, #{new_resource.title}!"
action :create
end
action :remove do
Chef::Log.info "Removing '#{new_resource.name}' greeting #{new_resource.path}"
file new_resource.path do
action :delete
end
end
第 3 步– 通过编辑 Testing_resource 默认配方使用新资源。
vipin@laptop:~/chef-repo $ subl cookbooks/Tesing_resource/recipes/default.rb greeting "Ohai" do title "Chef" action :create end
第 4 步– 将修改后的食谱上传到 Chef 服务器。
vipin@laptop:~/chef-repo $ knife cookbook upload greeting Uploading greeting [0.1.0]
第 5 步– 在节点上运行 Chef-Client。
vipin@server:~$ sudo chef-client ...TRUNCATED OUTPUT... 2013-06-28T21:32:54+00:00] INFO: Processing greeting[Ohai] action create (greeting::default line 9) [2013-06-28T21:32:54+00:00] INFO: Adding 'Ohai' greeting as /tmp/ greeting.txt [2013-06-28T21:32:54+00:00] INFO: Processing file[/tmp/greeting. txt] action create (/srv/chef/file_store/cookbooks/greeting/ providers/default.rb line 7) [2013-06-28T21:32:54+00:00] INFO: entered create [2013-06-28T21:32:54+00:00] INFO: file[/tmp/greeting.txt] created file /tmp/greeting.txt ...TRUNCATED OUTPUT...
步骤 6 – 验证生成文件的内容。
user@server:~$ cat /tmp/greeting.txt Ohai, Chef!
工作流脚本
LWRP 存在于食谱中。自定义资源位于说明书中，并且可以在说明书名称下使用。在工作流中，首先我们定义定义，然后将属性传递给将在说明书中使用的资源。最后，我们在配方中使用这些操作和属性。
厨师 – 蓝图
在 Chef 中，蓝图是找出并准确记录服务器上存在的内容的工具。蓝图记录了所需的所有内容，例如导演、包、配置文件等。蓝图能够以各种格式拆分服务器信息。其中之一是厨师食谱。这有助于使用 Chef 配置唯一的服务器。
工作方法
我们需要在需要运行蓝图的节点上安装 Python 和 Git。
步骤 1 – 安装蓝图。
vipin@server:~$ pip install blueprint
第 2 步– 创建蓝图。
user@server:~$ sudo blueprint create internal-cookbook # [blueprint] using cached blueprintignore(5) rules # [blueprint] searching for Python packages # [blueprint] searching for PEAR/PECL packages # [blueprint] searching for Yum packages # [blueprint] searching for Ruby gems # [blueprint] searching for npm packages # [blueprint] searching for software built from source # [blueprint] searching for configuration files # [blueprint] /etc/ssl/certs/AC_Ra\xc3\xadz_Certic\xc3\ xa1mara_S.A..pem not UTF-8 - skipping it # [blueprint] /etc/ssl/certs/NetLock_Arany_=Class_Gold=_F\xc5\ x91tan\xc3\xbas\xc3\xadtv\xc3\xa1ny.pem not UTF-8 - skipping it # [blueprint] /etc/ssl/certs/EBG_Elektronik_Sertifika_Hizmet_Sa\ xc4\x9flay\xc4\xb1c\xc4\xb1s\xc4\xb1.pem not UTF-8 - skipping it # [blueprint] /etc/ssl/certs/Certinomis_-_Autorit\xc3\xa9_Racine. pem not UTF-8 - skipping it # [blueprint] /etc/ssl/certs/T\xc3\x9cB\xc4\xb0TAK_UEKAE_K\xc3\ xb6k_Sertifika_Hizmet_Sa\xc4\x9flay\xc4\xb1c\xc4\xb1s\xc4\xb1_-_S\ xc3\xbcr\xc3\xbcm_3.pem not UTF-8 - skipping it # [blueprint] searching for APT packages # [blueprint] searching for service dependencies
第 3 步– 根据蓝图创建食谱。
user@server:~$ blueprint show -C internal-cookbook my-server/recipes/default.rb
步骤 4 – 验证生成文件的内容。
user@server:~$ cat internal-cookbook /recipes/default.rb
#
# Automatically generated by blueprint(7). Edit at your own risk.
#
cookbook_file('/tmp/96468fd1cc36927a027045b223c61065de6bc575.tar')
do
backup false
group 'root'
mode '0644'
owner 'root'
source 'tmp/96468fd1cc36927a027045b223c61065de6bc575.tar'
end
execute('/tmp/96468fd1cc36927a027045b223c61065de6bc575.tar') do
command 'tar xf "/tmp/96468fd1cc36927a027045b223c61065de6bc575.tar"'
cwd '/usr/local'
end
directory('/etc/apt/apt.conf.d') do
...TRUNCATED OUTPUT...
service('ssh') do
action [:enable, :start]
subscribes :restart, resources('cookbook_file[/etc/default/
keyboard]', 'cookbook_file[/etc/default/console-setup]',
'cookbook_file[/etc/default/ntfs-3g]', 'package[openssh-server]',
'execute[96468fd1cc36927a027045b223c61065de6bc575.tar]')
end
工作流脚本
Blueprint 是一个 Python 包，它找出服务器的所有相关配置数据并将其存储在 Git 存储库中。每个蓝图都有自己的名字。
可以要求蓝图以各种共振峰显示其 Git 存储库的内容。
user@server:~$ ls -l internal-cookbook / total 8 drwxrwxr-x 3 vagrant vagrant 4096 Jun 28 06:01 files -rw-rw-r-- 1 vagrant vagrant 0 Jun 28 06:01 metadata.rb drwxrwxr-x 2 vagrant vagrant 4096 Jun 28 06:01 recipes
蓝图显示命令
user@server:~$ blueprint show-packages my-server ...TRUNCATED OUTPUT... apt wireless-regdb 2011.04.28-1ubuntu3 apt zlib1g-dev 1:1.2.3.4.dfsg-3ubuntu4 python2.7 distribute 0.6.45 python2.7 pip 1.3.1 pip blueprint 3.4.2 pip virtualenv 1.9.1
前面的命令显示了各种已安装的包。其他显示命令如下 –
- 显示文件
- 演出服务
- 节目来源
Chef – 文件和包
在 Chef 中，创建配置文件和移动包是关键组件。Chef 有多种管理方式。Chef 支持多种方式处理文件和软件包。
从第三方仓库安装包
步骤 1 – 编辑食谱的默认配方。
vipin@laptop:~/chef-repo $ subl cookbooks/test_cookbook/recipes/default.rb include_recipe "apt" apt_repository "s3tools" do uri "http://s3tools.org/repo/deb-all" components ["stable/"] key "http://s3tools.org/repo/deb-all/stable/s3tools.key" action :add end package "s3cmd"
第 2 步– 编辑元数据以添加对 apt 食谱的依赖。
vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/metadata.rb ... depends "apt"
第 3 步– 将修改后的食谱上传到 Chef 服务器。
步骤 4 – 验证您尝试安装的软件包尚未安装。
步骤 5 – 验证默认存储库。
第 6 步– 在节点上运行 Chef-Client。
步骤 7 – 验证是否安装了所需的包。
从源安装软件
如果需要安装在给定平台上无法作为软件包提供的软件，则需要自己编译。在 Chef 中，我们可以通过使用脚本资源来做到这一点。
步骤 1 – 编辑默认配方。
vipin@laptop:~/chef-repo $ subl cookbooks/my_cookbook/recipes/
default.rb
version = "1.3.9"
bash "install_nginx_from_source" do
cwd Chef::Config['file_cache_path']
code &Lt-EOH
wget http://nginx.org/download/nginx-#{version}.tar.gz
tar zxf nginx-#{version}.tar.gz &&
cd nginx-#{version} &&
./configure && make && make install
EOH
第 2 步– 将修改后的食谱上传到 Chef 服务器。
第 3 步– 在节点上运行 Chef-Client。
第 4 步– 验证是否已安装 nginx。
厨师 – 社区食谱
社区食谱类似于任何其他食谱。它被称为社区食谱的唯一原因是因为任何知道编写食谱的人都可以加入这个社区并将他们的食谱上传到集中式中心。这些食谱是免费提供的，任何人都可以下载和使用。为了使用这些社区食谱，需要下载它们，根据需要修改它们，然后将它们上传到各自的 Chef 服务器。
为了更新、上传和下载食谱，需要在他们的系统上配置刀。使用刀食谱命令与食谱交互。使用刀食谱，您可以创建、删除、显示、列出、下载和上传食谱。阅读第 7 章中的 Knife Cookbook 命令文档以获取更多信息。
以下是社区食谱链接：https : //supermarket.chef.io/cookbooksdirectory
