Ansible入门到精通指南

5星 · 超过95%的资源需积分: 9 69 浏览量更新于2024-07-20 收藏 5.19MB PDF 举报

"Ansible.From.Beginner.to.Pro.1484216601" 本书《Ansible: 从入门到精通》是指导初学者掌握自动化工具Ansible的全面指南。它将帮助读者从零基础快速过渡到专业级的Ansible使用者。通过250页以内的篇幅，本书涵盖了从Ansible的下载安装，到在企业环境中实际应用的全部过程。首先，书中介绍了Ansible为何如此受欢迎，并详细解释了如何下载和安装Ansible。然后，通过创建一个Ansible playbook，读者可以学习如何自动设置环境，以便于安装开源项目。接下来，书中会教授如何将常见的任务抽象成可复用的角色，并且如何根据业务需求编写自定义角色。此外，作者还引导读者扩展Ansible，通过编写自己的模块来执行特定的业务操作。随着学习的深入，读者将学会构建整个虚拟机集群，所有应用程序及其依赖项都能自动安装。最后，书中的测试环节将帮助读者验证他们的Ansible playbook的正确性。本书适合那些目前手动创建开发和生产环境的开发者，特别是频繁使用包管理器进行安装的读者。Ansible提供的可重复性和时间节省功能对任何希望提升技能并学习新工具的开发者来说都极具价值。书中的章节涵盖了以下主题： 1. 开始入门：介绍Ansible的基础知识和基本概念。 2. 库存文件：讲解如何管理和配置Ansible的主机列表。 3. 安装WordPress：通过实际案例展示如何使用Ansible自动化部署Web应用。 4. Ansible角色：深入理解角色的创建和使用，实现任务的模块化。 5. 参数化Playbooks：学习如何通过变量和参数使Playbook更具灵活性。 6. 编写自定义模块：扩展Ansible的功能，满足特定需求。 7. 在AWS上编排：运用Ansible管理Amazon Web Services的基础设施。 8. 使用Test Kitchen和ServerSpec测试：集成测试工具确保自动化流程的可靠性。 9. 高级Ansible：探索更复杂的Ansible用法和最佳实践。 10. 附录A：安装Ansible：详细步骤帮助读者在不同平台上安装Ansible。 11. 附录B：YAML文件：解析YAML语法，它是Ansible的主要配置语言。《Ansible: 从入门到精通》是一本系统全面的教程，旨在帮助读者迅速掌握Ansible的使用，实现高效的IT基础设施和应用程序自动化管理。

CHAPTER 1 ■ GETTING STARTED

Initially, configuration management was about documenting the state of various

systems over time. However, as the available tools have improved, we seem to have

moved from an obligation to document that the system is in the desired state to declaring

the desired state and letting tools take care of it for us. We now define the system’s ideal

state rather than its current state, and Ansible ensures that everything is as it should be.

If it has to change versions of software or configuration files to make the system fit our

definition, Ansible will.

Infrastructure as Code

Historically, you would ensure that a system’s state matched what you expected and then

create a document certifying that this is the case. Today, we write that document as a

specification declaring the expected state of the system, then rely on tools such as Ansible

to implement the transformations required. Sure, we used to write small shell scripts that

would create a user or install and configure a specific software package, but that just isn’t

enough anymore. Infrastructure as code demands the same respect that we give to our

mission-critical software—code reviews, test suites, and proven software development

processes. All the things that you take for granted when writing code—version control,

design patterns, and so on—are not just for when you write code anymore. You can now

use the same techniques when defining your infrastructure as well.

While the shell scripts that you’ve written and refined over the years may work on

a small number of servers, how will you cope when your company’s business suddenly

takes off and you have to provision a dozen new servers identically? With the advent of

services like Amazon AWS, Rackspace Cloud, and other cloud services, the number of

machines a system administrator has to deal with on a daily basis has increased by an

order of magnitude. This is before you even consider the productivity enhancements

for developers resulting from having infrastructure defined as code. Developers’ being

able to spin up an environment on a cloud service or locally on a virtual machine to

test their changes is amazing. The cycle time from when a developer writes code to

its being deployed to production drops, as the code has been tested not only on an

system identical to the production servers, but it’s also been tested using the exact same

provisioning and deployment tools. In conclusion, infrastructure as code is a big thing,

and it’s not going away anytime soon .

About Ansible

Ansible was first released by Michael DeHaan in 2012 as a small side project, and it has

had a meteoric rise in popularity, with over 17,000 stars and 1,410 unique contributors

on Github. Stars on Github are a way to follow a the progress of a project that you’re

interested in, but aren’t necessarily contributing code to. Beyond being a successful

open-source project, it has been successfully used in enterprise by companies like Apple

and NASA, who rely on it for their configuration management needs.

The first AnsibleFest was held in Boston in 2013. In 2014, AnsibleFest went on

the road to New York City before moving to San Francisco for 2015. Developers and

operations staff from all over the world came together to talk about how Ansible has

helped them in their daily work lives and to discuss the future of Ansible.

CHAPTER 1 ■ GETTING STARTED

At the time of this writing, Ansible 2.1 has been released, and 2.2 is under active

development. The developers of Ansible have maintained backward compatibility

between version 1 and version 2 while adding some very useful functionality, such as

blocks (a way to catch errors during execution using try / catch ). Ansible 2.0 also supports

new playbook execution strategies, including standard linear execution and one that runs

a playbook as fast as possible.

Ansible uses YAML files as its main source of information at run time. YAML is a data

representation language that is commonly used for configuration. If you haven’t used

YAML, don’t worry. YAML files are really simple to write, and by the time you’ve created

one or two, you’ll have the hang of it. If you’ve ever used JSON or XML, you should feel right

at home; however, while JSON and XML aren’t very human friendly, YAML is very easy to

read and use. It does come with some quirks though, such as being whitespace sensitive.

Nonetheless, if you’ve ever written any Python code, this shouldn’t be an issue for you.

Which brings me to my next point — Ansible is written entirely in Python. The main

runner and all of the modules are Python 2.6 compatible, which means that they’ll work

with any version of Python2 above version 2.6. DeHaan choose Python for Ansible as it

meant that there would be no additional dependencies on the machines that you need to

manage. At this point in time, most other common configuration management systems

require you to install Ruby.

Not only are there no additional language dependencies for your machines, but also

there are no additional dependencies at all. Ansible works by running commands via

SSH, so there’s no need to install any server software. This is a huge plus for two reasons :

1 . Your machines run your application without any CPU or

memory-hungry daemons running in the background.

2 . You get everything that SSH provides for free. You can use

advanced features, such as ControlPersist, Kerberos, and

jump hosts. In addition, there is no need to roll your own

authentication mechanism — you can let SSH take care

of it for you!

Puppet, Chef, and Other Configuration Management

Tools

CFEngine was the original configuration management system. However, most people

nowadays compare Ansible to tools such as Puppet and Chef , which are most commonly

used today. Puppet and Chef are more similar to each other than they are to Ansible, but they

can perform the same functions. While Puppet and Chef each use a central server to store

the desired state of machines and any metadata associated with them, Ansible doesn’t have

any central server at all (making it agentless). This is important, as when using tools such as

Puppet and Chef each server will check in periodically with the central server to see if there

are any updates. Ansible relies entirely on the end user pushing out the changes themselves.

Ansible more closely resembles a tool called SaltStack (Salt), which also uses YAML

files for configuration and is also written in Python. Both Ansible and Salt are built primarily

as execution engines, where your system definition is just a list of commands to run,

abstracted behind reusable modules that provide an idempotent interface to your servers.

Thanks to most of Ansible’s modules and Salt’s state modules being idempotent, both tools

can be used to define the state of a machine before the tool will run and enforce that state.

CHAPTER 1 ■ GETTING STARTED

As previously mentioned, Ansible uses an “agentless” model where changes are

pushed out to machines on demand. This is different than Puppet and Chef, where there

is a central server that is seen as the single source of truth, and machines periodically

check with the server to ensure that they have the latest copy of everything they need.

This has its advantages and disadvantages: the good news is that once you make changes,

you can instantly push these changes out to machines without waiting for a daemon

to check if there are any changes. The bad news is that you are responsible for getting

updates out to your machines, whereas with Puppet and Chef you can just commit your

changes and know that they’ll be rolled out soon. It’s worth mentioning that Ansible can

support this pull model as well, but we’ll talk about that a little later on in Chapter

9 .

As mentioned earlier, Ansible uses SSH to connect from the host machine to other

systems. While this gives us a lot of confidence in its transport mechanism, it can also

be quite slow. Conversely, Salt uses ZeroMQ, which is very fast when bootstrapping a

connection and sending commands to the recipient.

Installing Ansible

Installing Ansible is easy. However, installing the correct version of Ansible isn’t quite

as easy.

Ansible is available in the package repositories for operating systems such as Ubuntu

( apt-get ) and Fedora ( yum ), but the versions in those repositories are usually several

releases out of date. As Ansible is under rapid development, you’ll want the latest release

available—either by building it yourself or installing it via a package manager.

The easiest way to ensure that you always have the latest version available is to grab

the source code from

https://github.com/ansible/ansible and build it yourself.

■ Note You’ll need a development environment set up to build Ansible from source code.

This involves having git , pip , and the Python development libraries installed. See Appendix

A, “Building Ansible,” for more information.

Once you have all of the required dependencies installed, you can download Ansible

from Github and build it:

git clone git://github.com/ansible/ansible.git --recursive

cd ansible

make

sudo make install

This will build and install the latest development version of Ansible for you from

source. If you’re running on a Debian or a RedHat Linux machine, you might prefer

to use dkpg or yum to install Ansible. Using dpkg or yum and installing via your system’s

package manager is preferred, as it provides a way to uninstall Ansible cleanly. For more

information on building Debian and RPM packages, see Appendix A, “Building Ansible.”

CHAPTER 1 ■ GETTING STARTED

If you’re running an operating system that doesn’t have yum or apt , you can install

Ansible via its Makefile. To install Ansible via the Makefile, all you have to do is run sudo

make install . This will copy Ansible into the correct location on your machine.

If you don’t want to download the source code and install it yourself, you can use a

package manager such as apt , yum , or brew .

If you’re on OS X, you can use Homebrew (

http://brew.sh ) to install Ansible. This

is almost identical to the make example above. All you need to do is type brew install

ansible and it’ll grab the latest version on record.

If you’re on a Debian-based OS, you have two options: either use an Ansible PPA or

install via Pip.

If you want to install via the PPA, you’ll need to enable it and update your apt cache.

If apt-add-repository doesn’t exist on your system, you may have to install python-

software-properties first, as follows:

sudo apt-get install python-software-properties # if required

sudo apt-add-repository ppa:ansible/ansible

sudo apt-get update

sudo apt-get install ansible

If you’re on an OS that doesn’t support PPAs or if you’d prefer to use Pip, you can do

that too, as shown here:

sudo pip install ansible

■ Note Ansible is not officially supported on Windows, but it is possible to get it running.

I would not recommend installing Ansible locally if you’re on Windows, but instead use

Vagrant’s local Ansible provisioner to run the tool. If you do want to try running it locally, read

the next paragraph.

Finally, we come to Windows. Unfortunately, Ansible does not run on Windows

without quite a lot of work (and even then it’s not officially supported). Throughout

this book, we’ll be using a virtual machine to develop our playbook, which means that

installing Ansible on Windows isn’t strictly necessary. If you’re running on Windows, I’d

recommend not installing Ansible locally and instead running it from inside a virtual

machine that you create (which we’ll cover in the next section).

If you’re determined to try running Ansible on Windows, you can find the

instructions to install it in Appendix A.

Writing Your First Playbook

Now that you have Ansible installed, you can start automating your infrastructure. You’ll

need an environment in which to test and a playbook to run. We’ll use a tool called

Vagrant to provide a disposable development environment and create a playbook that

installs a basic PHP and MySQL stack.

CHAPTER 1 ■ GETTING STARTED

Creating a Test Environment with Vagrant

Before you write your first playbook, you’ll need an environment in which to test it. While

you could write playbooks to run against your local machine, I recommend testing them

in an environment where it doesn’t matter if things don’t quite work as intended, just in

case something goes wrong. To create these environments, I use Vagrant.

If you’re new to Vagrant, keep on reading this chapter to learn what it is and how it

can help. If you’re familiar with Vagrant, or you’re eager to get started, feel free to skip to

the end of the chapter and run the commands provided to help you get up and running.

About VirtualBox and Vagrant

Throughout this book, we’ll be using a virtual machine against which we will run our

playbooks. This virtual machine will be provided using a combination of VirtualBox

(for the virtualization technology) and Vagrant (to automate the creation of virtualized

machines). Both of these tools are freely available online at

http://virtualbox.com and

http://vagrantup.com respectively.

VirtualBox is a free virtualization tool developed by Oracle. It allows you to create

a virtual PC and install any operating system as though you were on physical hardware.

You can use VirtualBox as standalone software, but it works best when used with Vagrant,

which is essentially a scripting language for virtual machines.

Vagrant is the glue that binds everything together. You could theoretically spin up a

VirtualBox machine yourself, then run Ansible on it, but Vagrant gives you a way to define

all of that programmatically. This configuration can then be committed with your code,

and any time it changes, everyone will have the latest version the next time they pull

updates down. Throughout this book we’ll be using a virtual machine, but it’s useful to

know that Vagrant can also be used to control real hardware.

Installing VirtualBox and Vagrant

■ Note If you’re using some form of package manager, such as apt or yum , don’t use it

to install VirtualBox and Vagrant. Both of these tools are under active development, and the

versions provided in the repositories are usually several months out of date.

VirtualBox is available online at https://www.virtualbox.org/wiki/Downloads for

many different platforms. VirtualBox is only available for 64-bit systems as of version 5.0.

While you can download an old release for 32-bit systems, I would recommend upgrading,

as the rest of this book assumes a 64-bit machine.

Once you have VirtualBox installed, you can download Vagrant from

https://www.

vagrantup.com/downloads.html

. It should be as simple as downloading and running the

installer for your chosen operating system.

剩余181页未读，继续阅读

ramissue

粉丝: 354
资源: 1487

Ansible入门到精通指南

Apress.Ansible.From.Beginner.to.Pro.1484216601-182页

centos_7_1_ansible.tar.gz

ansible.tar.gz

ansible.cfg在哪里

没有ansible.cfg

ansible 2.9.27手动安装ansible.netcommon合集

安装ansible.posix集合

ansible 2.9.27手动导入ansible.netcommon合集

ansible.builtin.mv

最新资源