标签 Ansible 下的文章

我使用 Ansible 来自动部署站点 (LinuxJobs.frJournal du hacker) 与应用 (Feed2tootFeed2tweet)。在本文中将会讲述我是如何配置以实现在本地测试 Ansbile 剧本 playbook 的。

ansible

为何要测试 Ansible 剧本

我需要一种简单而迅速的方法来在我的本地笔记本上测试 Ansible 剧本的部署情况,尤其在刚开始写一个新剧本的时候,因为直接部署到生产服务器上不仅特别慢而且风险还很大。

我使用 Vagrant 来将剧本部署到 VirtualBox 虚拟机上而不是部署到远程服务器。这使得修改的结果很快就能看到,以实现快速迭代和修正。

责任声明:我并不是专业程序员。我只是描述一种我觉得适合我的,即简单又有效的用来测试 Ansible 剧本的解决方案,但可能还有其他更好的方法。

我的流程

  1. 开始写新的 Ansible 剧本
  2. 启动一台新的虚拟机(VM)并使用 Vagrantt 将剧本部署到这台虚拟机中
  3. 修复剧本或应用中的错误
  4. 重新在虚拟机上部署
  5. 如果还有问题,回到第三步。否则销毁这台虚拟机,重新创建新虚拟机然后测试一次全新部署
  6. 若没有问题出现,则标记你的 Ansible 剧本版本,可以在生产环境上发布产品了

你需要哪些东西

首先,你需要 Virtualbox。若你使用的是 Debian 发行版,这个链接 描述了安装的方法,可以从 Debian 仓库中安装,也可以通过官网来安装。

其次,你需要 Vagrant。为什么要 Vagrant?因为它是介于开发环境和虚拟机之间的中间件,它允许通过编程的方式重复操作,而且可以很方便地将你的部署环境与虚拟机连接起来。通过下面命令可以安装 Vagrant:

# apt install vagrant

设置 Vagrant

Vagrant 的一切信息都存放在 Vagrantfile 文件中。这是我的内容:

Vagrant.require_version ">= 2.0.0"

Vagrant.configure(1) do |config|

 config.vm.box = "debian/stretch64"
 config.vm.provision "shell", inline: "apt install --yes git python3-pip"
 config.vm.provision "ansible" do |ansible|
   ansible.verbose = "v"
   ansible.playbook = "site.yml"
   ansible.vault_password_file = "vault_password_file"
 end
end
  1. 第一行指明了需要用哪个版本的 Vagrant 来执行 Vagrantfile
  2. 文件中的第一个循环,你要定义为多少台虚拟机执行下面的操作(这里为 1)。
  3. 第三行指定了用来创建虚拟机的官方 Vagrant 镜像。
  4. 第四行非常重要:有一些需要的应用没有安装到虚拟机中。这里我们用 apt 安装 gitpython3-pip
  5. 下一行指明了 Ansible 配置开始的地方
  6. 第六行说明我们想要 Ansible 输出详细信息。
  7. 第七行,我们定义了 Ansible 剧本的入口。
  8. 第八行,若你使用 Ansible Vault 加密了一些文件,在这里指定这些文件。

当 Vagrant 启动 Ansible 时,类似于执行这样的操作:

$  ansible-playbook --inventory-file=/home/me/ansible/test-ansible-playbook/.vagrant/provisioners/ansible/inventory -v --vault-password-file=vault_password_file site.yml

执行 Vagrant

写好 Vagrantfile 后,就可以启动虚拟机了。只需要简单地运行下面命令:

$ vagrant up

这个操作会很慢,因为它会启动虚拟机,安装 Vagrantfile 中定义的附加软件,最终应用你的剧本。你不要太频繁地使用这条命令。

Ok,现在你可以快速迭代了。在做出修改后,可以通过下面命令来快速测试你的部署:

$ vagrant provision

Ansible 剧本搞定后,通常要经过多次迭代(至少我是这样的),你应该一个全新安装的虚拟机上再测试一次,因为你在迭代的过程中可能会对虚拟机造成修改从而引发意料之外的结果。

使用下面命令进行全新测试:

$ vagrant destroy && vagrant up

这又是一个很慢的操作。你应该在 Ansible 剧本差不多完成了的情况下才这样做。在全新虚拟机上测试部署之后,就可以发布到生产上去了。至少准备要充分不少了吧 :p

有什么改进意见?请告诉我

本文中描述的配置对我自己来说很有用。我可以做到快速迭代(尤其在编写新的剧本的时候),除了剧本外,对我的最新应用,尚未准备好部署到生产环境上的应用也很有帮助。直接部署到远程服务器上对我的生产服务来说不仅缓慢而且很危险。

我本也可以使用持续集成(CI)服务器,但这不是本文的主题。如前所述,本文的目的是在编写新的 Ansible 剧本之初尽可能的快速迭代。

在编写 Ansible 剧本之初就提交,推送到你的 Git 仓库然后等待 CI 测试的执行结果,这有点太过了,因为这个时期的错误总是很多,你需要一一个地去调试。我觉得 CI 在编写 Ansible 剧本的后期会有用的多,尤其当多个人同时对它进行修改而且你有一整套代码质量规范要遵守的时候。不过,这只是我自己的观念,还有待讨论,再重申一遍,我不是个专业的程序员。

如果你有更好的测试 Ansible 剧本的方案或者能对这里描述的方法做出一些改进,请告诉我。你可以把它写到留言框中或者通过社交网络联系我,我会很高兴的。


via: https://carlchenet.com/testing-ansible-playbooks-with-vagrant/

作者:Carl Chenet 译者:lujun9972 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

这些年来,我已经写了许多关于 DevOps 工具的文章,也培训了这方面的人员。尽管这些工具很棒,但很明显,大多数都是按照开发人员的思路设计出来的。这也没有什么问题,因为以编程的方式接近配置管理是重点。不过,直到我开始接触 Ansible,我才觉得这才是系统管理员喜欢的东西。

喜欢的一部分原因是 Ansible 与客户端计算机通信的方式,是通过 SSH 的。作为系统管理员,你们都非常熟悉通过 SSH 连接到计算机,所以从单词“去”的角度来看,相对于其它选择,你更容易理解 Ansible。

考虑到这一点,我打算写一些文章,探讨如何使用 Ansible。这是一个很好的系统,但是当我第一次接触到这个系统的时候,不知道如何开始。这并不是学习曲线陡峭。事实上,问题是在开始使用 Ansible 之前,我并没有太多的东西要学,这才是让人感到困惑的。例如,如果您不必安装客户端程序(Ansible 没有在客户端计算机上安装任何软件),那么您将如何启动?

踏出第一步

起初 Ansible 对我来说非常困难的原因在于配置服务器/客户端的关系是非常灵活的,我不知道我该从何入手。事实是,Ansible 并不关心你如何设置 SSH 系统。它会利用你现有的任何配置。需要考虑以下几件事情:

  1. Ansible 需要通过 SSH 连接到客户端计算机。
  2. 连接后,Ansible 需要提升权限才能配置系统,安装软件包等等。

不幸的是,这两个考虑真的带来了一堆蠕虫。连接到远程计算机并提升权限是一件可怕的事情。当您在远程计算机上安装代理并使用 Chef 或 Puppet 处理特权升级问题时,似乎感觉就没那么可怕了。 Ansible 并非不安全,而是安全的决定权在你手中。

接下来,我将列出一系列潜在的配置,以及每个配置的优缺点。这不是一个详尽的清单,但是你会受到正确的启发,去思考在你自己的环境中什么是理想的配置。也需要注意,我不会提到像 Vagrant 这样的系统,因为尽管 Vagrant 在构建测试和开发的敏捷架构时非常棒,但是和一堆服务器是非常不同的,因此考虑因素是极不相似的。

一些 SSH 场景

1)在 Ansible 配置中,root 用户以密码进入远程计算机。

拥有这个想法是一个非常可怕的开始。这个设置的“优点”是它消除了对特权提升的需要,并且远程服务器上不需要其他用户帐户。 但是,这种便利的成本是不值得的。 首先,大多数系统不会让你在不改变默认配置的情况下以 root 身份进行 SSH 登录。默认的配置之所以如此,坦率地说,是因为允许 root 用户远程连接是一个不好的主意。 其次,将 root 密码放在 Ansible 机器上的纯文本配置文件中是不合适的。 真的,我提到了这种可能性,因为这是可以的,但这是应该避免的。 请记住,Ansible 允许你自己配置连接,它可以让你做真正愚蠢的事情。 但是请不要这么做。

2)使用存储在 Ansible 配置中的密码,以普通用户的身份进入远程计算机。

这种情况的一个优点是它不需要太多的客户端配置。 大多数用户默认情况下都可以使用 SSH,因此 Ansible 应该能够使用用户凭据并且能够正常登录。 我个人不喜欢在配置文件中以纯文本形式存储密码,但至少它不是 root 密码。 如果您使用此方法,请务必考虑远程服务器上的权限提升方式。 我知道我还没有谈到权限提升,但是如果你在配置文件中配置了一个密码,这个密码可能会被用来获得 sudo 访问权限。 因此,一旦发生泄露,您不仅已经泄露了远程用户的帐户,还可能泄露整个系统。

3)使用具有空密码的密钥对进行身份验证,以普通用户身份进入远程计算机。

这消除了将密码存储在配置文件中的弊端,至少在登录的过程中消除了。 没有密码的密钥对并不理想,但这是我经常做的事情。 在我的个人内部网络中,我通常使用没有密码的密钥对来自动执行许多事情,如需要身份验证的定时任务。 这不是最安全的选择,因为私钥泄露意味着可以无限制地访问远程用户的帐户,但是相对于在配置文件中存储密码我更喜欢这种方式。

4)使用通过密码保护的密钥对进行身份验证,以普通用户的身份通过 SSH 连接到远程计算机。

这是处理远程访问的一种非常安全的方式,因为它需要两种不同的身份验证因素来解密:私钥和密码。 如果你只是以交互方式运行 Ansible,这可能是理想的设置。 当你运行命令时,Ansible 会提示你输入私钥的密码,然后使用密钥对登录到远程系统。 是的,只需使用标准密码登录并且不用在配置文件中指定密码即可完成,但是如果不管怎样都要在命令行上输入密码,那为什么不在保护层添加密钥对呢?

5)使用密码保护密钥对进行 SSH 连接,但是使用 ssh-agent “解锁”私钥。

这并不能完美地解决无人值守、自动化的 Ansible 命令的问题,但是它确实也使安全设置变得相当方便。 ssh-agent 程序一次验证密码,然后使用该验证进行后续连接。当我使用 Ansible 时,这是我想要做的事情。如果我是完全值得信任的,我通常仍然使用没有密码的密钥对,但是这通常是因为我在我的家庭服务器上工作,是不是容易受到攻击的。

在配置 SSH 环境时还要记住一些其他注意事项。 也许你可以限制 Ansible 用户(通常是你的本地用户),以便它只能从一个特定的 IP 地址登录。 也许您的 Ansible 服务器可以位于不同的子网中,位于强大的防火墙之后,因此其私钥更难以远程访问。 也许 Ansible 服务器本身没有安装 SSH 服务器,所以根本没法访问。 同样,Ansible 的优势之一是它使用 SSH 协议进行通信,而且这是一个你用了多年的协议,你已经把你的系统调整到最适合你的环境了。 我不是宣传“最佳实践”的忠实粉丝,因为实际上最好的做法是考虑你的环境,并选择最适合你情况的设置。

权限提升

一旦您的 Ansible 服务器通过 SSH 连接到它的客户端,就需要能够提升特权。 如果你选择了上面的选项 1,那么你已经是 root 了,这是一个有争议的问题。 但是由于没有人选择选项 1(对吧?),您需要考虑客户端计算机上的普通用户如何获得访问权限。 Ansible 支持各种权限提升的系统,但在 Linux 中,最常用的选项是 sudosu。 和 SSH 一样,有几种情况需要考虑,虽然肯定还有其他选择。

1)使用 su 提升权限。

对于 RedHat/CentOS 用户来说,可能默认是使用 su 来获得系统访问权限。 默认情况下,这些系统在安装过程中配置了 root 密码,要想获得特殊访问权限,您需要输入该密码。使用 su 的问题在于,虽说它可以给了您完全访问远程系统,而您确实也可以完全访问远程系统。 (是的,这是讽刺。)另外,su 程序没有使用密钥对进行身份验证的能力,所以密码必须以交互方式输入或存储在配置文件中。 由于它实际上是 root 密码,因此将其存储在配置文件中听起来像、也确实是一个可怕的想法。

2)使用 sudo 提升权限。

这就是 Debian/Ubuntu 系统的配置方式。 正常用户组中的用户可以使用 sudo 命令并使用 root 权限执行该命令。 随之而来的是,这仍然存在密码存储或交互式输入的问题。 由于在配置文件中存储用户的密码看起来不太可怕,我猜这是使用 su 的一个进步,但是如果密码被泄露,仍然可以完全访问系统。 (毕竟,输入 sudosu - 都将允许用户成为 root 用户,就像拥有 root 密码一样。)

3) 使用 sudo 提升权限,并在 sudoers 文件中配置 NOPASSWD。

再次,在我的本地环境中,我就是这么做的。 这并不完美,因为它给予用户帐户无限制的 root 权限,并且不需要任何密码。 但是,当我这样做并且使用没有密码短语的 SSH 密钥对时,我可以让 Ansible 命令更轻松的自动化。 再次提示,虽然这很方便,但这不是一个非常安全的想法。

4)使用 sudo 提升权限,并在特定的可执行文件上配置 NOPASSWD。

这个想法可能是安全性和便利性的最佳折衷。 基本上,如果你知道你打算用 Ansible 做什么,那么你可以为远程用户使用的那些应用程序提供 NOPASSWD 权限。 这可能会让人有些困惑,因为 Ansible 使用 Python 来处理很多事情,但是经过足够的尝试和错误,你应该能够弄清原理。 这是额外的工作,但确实消除了一些明显的安全漏洞。

计划实施

一旦你决定如何处理 Ansible 认证和权限提升,就需要设置它。 在熟悉 Ansible 之后,您可能会使用该工具来帮助“引导”新客户端,但首先手动配置客户端非常重要,以便您知道发生了什么事情。 将你熟悉的事情变得自动化比从头开始自动化要好。

我已经写过关于 SSH 密钥对的文章,网上有无数的设置类的文章。 来自 Ansible 服务器的简短版本看起来像这样:

# ssh-keygen
# ssh-copy-id -i .ssh/id_dsa.pub remoteuser@remote.computer.ip
# ssh remoteuser@remote.computer.ip

如果您在创建密钥对时选择不使用密码,最后一步您应该可以直接进入远程计算机,而不用输入密码或密钥串。

为了在 sudo 中设置权限提升,您需要编辑 sudoers 文件。 你不应该直接编辑文件,而是使用:

# sudo visudo

这将打开 sudoers 文件并允许您安全地进行更改(保存时会进行错误检查,所以您不会意外地因为输入错误将自己锁住)。 这个文件中有一些例子,所以你应该能够弄清楚如何分配你想要的确切的权限。

一旦配置完成,您应该在使用 Ansible 之前进行手动测试。 尝试 SSH 到远程客户端,然后尝试使用您选择的任何方法提升权限。 一旦你确认配置的方式可以连接,就可以安装 Ansible 了。

安装 Ansible

由于 Ansible 程序仅安装在一台计算机上,因此开始并不是一件繁重的工作。 Red Hat/Ubuntu 系统的软件包安装有点不同,但都不是很困难。

在 Red Hat/CentOS 中,首先启用 EPEL 库:

sudo yum install epel-release

然后安装 Ansible:

sudo yum install ansible

在 Ubuntu 中,首先启用 Ansible PPA:

sudo apt-add-repository spa:ansible/ansible
(press ENTER to access the key and add the repo)

然后安装 Ansible:

sudo apt-get update
sudo apt-get install ansible

Ansible 主机文件配置

Ansible 系统无法知道您希望它控制哪个客户端,除非您给它一个计算机列表。 该列表非常简单,看起来像这样:

# file /etc/ansible/hosts

[webservers]
blogserver ansible_host=192.168.1.5
wikiserver ansible_host=192.168.1.10

[dbservers]
mysql_1 ansible_host=192.168.1.22
pgsql_1 ansible_host=192.168.1.23

方括号内的部分是指定的组。 单个主机可以列在多个组中,而 Ansible 可以指向单个主机或组。 这也是配置文件,比如纯文本密码的东西将被存储,如果这是你计划的那种设置。 配置文件中的每一行配置一个主机地址,并且可以在 ansible_host 语句之后添加多个声明。 一些有用的选项是:

ansible_ssh_pass
ansible_become
ansible_become_method
ansible_become_user
ansible_become_pass

Ansible 保险库 Vault

(LCTT 译注:Vault 作为 ansible 的一项新功能可将例如密码、密钥等敏感数据文件进行加密,而非明文存放)

我也应该注意到,尽管安装程序比较复杂,而且这不是在您首次进入 Ansible 世界时可能会做的事情,但该程序确实提供了一种加密保险库中的密码的方法。 一旦您熟悉 Ansible,并且希望将其投入生产,将这些密码存储在加密的 Ansible 保险库中是非常理想的。 但是本着先学会爬再学会走的精神,我建议首先在非生产环境下使用无密码方法。

系统测试

最后,你应该测试你的系统,以确保客户端可以正常连接。 ping 测试将确保 Ansible 计算机可以 ping 每个主机:

ansible -m ping all

运行后,如果 ping 成功,您应该看到每个定义的主机显示 ping 的消息:pong。 这实际上并没有测试认证,只是测试网络连接。 试试这个来测试你的认证:

ansible -m shell -a 'uptime' webservers

您应该可以看到 webservers 组中每个主机的运行时间命令的结果。

在后续文章中,我计划开始深入 Ansible 管理远程计算机的功能。 我将介绍各种模块,以及如何使用 ad-hoc 模式来完成一些按键操作,这些操作在命令行上单独处理都需要很长时间。 如果您没有从上面的示例 Ansible 命令中获得预期的结果,请花些时间确保身份验证可以工作。 如果遇到困难,请查阅 Ansible 文档获取更多帮助。


via: http://www.linuxjournal.com/content/ansible-automation-framework-thinks-sysadmin

作者:Shawn Powers 译者:Flowsnow 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

我想使用 Ansible 工具创建 Amazon EC2 密钥对。不想使用 AWS CLI 来创建。可以使用 Ansible 来创建 AWS ec2 密钥吗?

你需要使用 Ansible 的 ec2\_key 模块。这个模块依赖于 python-boto 2.5 版本或者更高版本。 boto 是亚马逊 Web 服务的一个 Python API。你可以将 boto 用于 Amazon S3、Amazon EC2 等其他服务。简而言之,你需要安装 Ansible 和 boto 模块。我们一起来看下如何安装 boto 并结合 Ansible 使用。

第一步 - 在 Ubuntu 上安装最新版本的 Ansible

你必须给你的系统配置 PPA 来安装最新版的 Ansible。为了管理你从各种 PPA(Personal Package Archives)安装软件的仓库,你可以上传 Ubuntu 源码包并编译,然后通过 Launchpad 以 apt 仓库的形式发布。键入如下命令 apt-get 命令或者 apt 命令

$ sudo apt update 
$ sudo apt upgrade 
$ sudo apt install software-properties-common

接下来给你的系统的软件源中添加 ppa:ansible/ansible

$ sudo apt-add-repository ppa:ansible/ansible

更新你的仓库并安装 Ansible:

$ sudo apt update 
$ sudo apt install ansible

安装 boto:

$ pip3 install boto3

关于在CentOS/RHEL 7.x上安装 Ansible 的注意事项

需要在 CentOS 和 RHEL 7.x 上配置 EPEL 源yum命令

$ cd /tmp 
$ wget https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm 
$ ls *.rpm 
$ sudo yum install epel-release-latest-7.noarch.rpm 
$ sudo yum install ansible

安装 boto:

$ pip install boto3

第二步 2 – 配置 boto

你需要配置 AWS credentials/API 密钥。参考 “AWS Security Credentials” 文档如何创建 API key。用 mkdir 命令创建一个名为 ~/.aws 的目录,然后配置 API key:

$ mkdir -pv ~/.aws/ 
$ vi ~/.aws/credentials
[default]
aws_access_key_id = YOUR-ACCESS-KEY-HERE
aws_secret_access_key = YOUR-SECRET-ACCESS-KEY-HERE

还需要配置默认 AWS 区域

$ vi ~/.aws/config

输出样例如下:

[default]
region = us-west-1

通过创建一个简单的名为 test-boto.py 的 Python 程序来测试你的 boto 配置是否正确:

#!/usr/bin/python3
# A simple program to test boto and print s3 bucket names
import boto3
t = boto3.resource('s3')
for b in t.buckets.all():
 print(b.name)

按下面方式来运行该程序:

$ python3 test-boto.py

输出样例:

nixcraft-images
nixcraft-backups-cbz
nixcraft-backups-forum

上面输出可以确定 Python-boto 可以使用 AWS API 正常工作。

步骤 3 - 使用 Ansible 创建 AWS ec2 密钥

创建一个名为 ec2.key.yml 的剧本,如下所示:

---
- hosts: local
  connection: local
  gather_facts: no
  tasks:
 
 - name: Create a new EC2 key
   ec2_key:
   name: nixcraft-key
   region: us-west-1
   register: ec2_key_result
 
 - name: Save private key
   copy: content="{{ ec2_key_result.key.private_key }}" dest="./aws.nixcraft.pem" mode=0600
   when: ec2_key_result.changed

其中,

  • ec2_key: – ec2 密钥对。
  • name: nixcraft_key – 密钥对的名称。
  • region: us-west-1 – 使用的 AWS 区域。
  • register: ec2_key_result – 保存生成的密钥到 ec2keyresult 变量。
  • copy: content="{{ ec2_key_result.key.private_key }}" dest="./aws.nixcraft.pem" mode=0600 – 将 ec2_key_result.key.private_key 的内容保存到当前目录的一个名为 aws.nixcraft.pem 的文件中。设置该文件的权限为 0600 (unix 文件权限)。
  • when: ec2_key_result.changed – 仅仅在 ec2_key_result 改变时才保存。我们不想覆盖你的密钥文件。

你还必须创建如下 hosts 文件:

[local]
localhost

如下运行你的剧本:

$ ansible-playbook -i hosts ec2.key.yml

最后你应该有一个名为 `aws.nixcraft.pem 私钥,该私钥可以和 AWS EC2 一起使用。使用 cat 命令查看你的密钥:

$ cat aws.nixcraft.pem

如果你有 EC2 虚拟机,请按如下方式使用:

$ ssh -i aws.nixcraft.pem user@ec2-vm-dns-name

查看有关 python 数据结构变量名的信息,比如 ec2keyresult.changed 和 ec2keyresult.key.private\_key

你一定在想我是如何使用变量名的,比如 ec2_key_result.changedec2_key_result.key.private_key。它们在哪里定义过吗?变量的值是通过 API 调用返回的。简单地使用 -v 选项运行 ansible-playbook 命令来查看这样的信息:

$ ansible-playbook -v -i hosts ec2.key.yml

我该如何删除一个密钥?

使用如下 ec2-key-delete.yml

---
- hosts: local
  connection: local
  gather_facts: no
  tasks:
 
 - name: Delete a EC2 key
   ec2_key:
   name: nixcraft-key
   region: us-west-1
# absent means delete keypair
   state: absent

按照如下方式运行:

$ ansible-playbook -i hosts ec2-key-delete.yml

关于作者

作者是 nixCraft 的创始人,是一个经验丰富的系统管理员,DevOps 工程师,同时是一个 Linux 操作系统/Unix shell 脚本培训师。通过 RSS/XML 提要每周邮件简讯获得关于系统管理,Linux/Unix和开放源码主题的最新教程。


via: https://www.cyberciti.biz/faq/how-to-create-aws-ec2-key-using-ansible/

作者:Vivek Gite 译者:qianghaohao 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

精进你的系统管理能力和 Linux 技能,学习如何设置工具来简化管理多台机器。

你是否想精进你的系统管理能力和 Linux 技能?也许你的本地局域网上跑了一些东西,而你又想让生活更轻松一点--那该怎么办呢?在本文中,我会向你演示如何设置工具来简化管理多台机器。

远程管理工具有很多,SaltStack、Puppet、Chef,以及 Ansible 都是很流行的选择。在本文中,我将重点放在 Ansible 上并会解释它是如何帮到你的,不管你是有 5 台还是 1000 台虚拟机。

让我们从多机(不管这些机器是虚拟的还是物理的)的基本管理开始。我假设你知道要做什么,有基础的 Linux 管理技能(至少要有能找出执行每个任务具体步骤的能力)。我会向你演示如何使用这一工具,而是否使用它由你自己决定。

什么是 Ansible?

Ansible 的网站上将之解释为 “一个超级简单的 IT 自动化引擎,可以自动进行云供给、配置管理、应用部署、服务内部编排,以及其他很多 IT 需求。” 通过在一个集中的位置定义好服务器集合,Ansible 可以在多个服务器上执行相同的任务。

如果你对 Bash 的 for 循环很熟悉,你会发现 Ansible 操作跟这很类似。区别在于 Ansible 是 幕等的 idempotent 。通俗来说就是 Ansible 一般只有在确实会发生改变时才执行所请求的动作。比如,假设你执行一个 Bash 的 for 循环来为多个机器创建用户,像这样子:

for server in serverA serverB serverC; do ssh ${server} "useradd myuser"; done

这会在 serverA、serverB,以及 serverC 上创建 myuser 用户;然而不管这个用户是否存在,每次运行这个 for 循环时都会执行 useradd 命令。一个幕等的系统会首先检查用户是否存在,只有在不存在的情况下才会去创建它。当然,这个例子很简单,但是幕等工具的好处将会随着时间的推移变得越发明显。

Ansible 是如何工作的?

Ansible 会将 Ansible playbooks 转换成通过 SSH 运行的命令,这在管理类 UNIX 环境时有很多优势:

  1. 绝大多数类 UNIX 机器默认都开了 SSH。
  2. 依赖 SSH 意味着远程主机不需要有代理。
  3. 大多数情况下都无需安装额外的软件,Ansible 需要 2.6 或更新版本的 Python。而绝大多数 Linux 发行版默认都安装了这一版本(或者更新版本)的 Python。
  4. Ansible 无需主节点。他可以在任何安装有 Ansible 并能通过 SSH 访问的主机上运行。
  5. 虽然可以在 cron 中运行 Ansible,但默认情况下,Ansible 只会在你明确要求的情况下运行。

配置 SSH 密钥认证

使用 Ansible 的一种常用方法是配置无需密码的 SSH 密钥登录以方便管理。(可以使用 Ansible Vault 来为密码等敏感信息提供保护,但这不在本文的讨论范围之内)。现在只需要使用下面命令来生成一个 SSH 密钥,如示例 1 所示。

[09:44 user ~]$ ssh-keygen
Generating public/private rsa key pair。
Enter file in which to save the key (/home/user/.ssh/id_rsa):
Created directory '/home/user/.ssh'。
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/user/.ssh/id_rsa。
Your public key has been saved in /home/user/.ssh/id_rsa.pub。
The key fingerprint is:
SHA256:TpMyzf4qGqXmx3aqZijVv7vO9zGnVXsh6dPbXAZ+LUQ user@user-fedora
The key's randomart image is:
+---[RSA 2048]----+
|                 |
|                 |
|              E  |
|       o .   .。|
|   .  + S    o+。|
|  . .o * .  .+ooo|
| . .+o  o o oo+。*|
|。.ooo* o。*  .*+|
| . o+*BO.o+    .o|
+----[SHA256]-----+

示例 1 :生成一个 SSH 密钥

在示例 1 中,直接按下回车键来接受默认值。任何非特权用户都能生成 SSH 密钥,也能安装到远程系统中任何用户的 SSH 的 authorized_keys 文件中。生成密钥后,还需要将之拷贝到远程主机上去,运行下面命令:

ssh-copy-id root@servera

注意:运行 Ansible 本身无需 root 权限;然而如果你使用非 root 用户,你需要为要执行的任务配置合适的 sudo 权限。

输入 servera 的 root 密码,这条命令会将你的 SSH 密钥安装到远程主机上去。安装好 SSH 密钥后,再通过 SSH 登录远程主机就不再需要输入 root 密码了。

安装 Ansible

只需要在示例 1 中生成 SSH 密钥的那台主机上安装 Ansible。若你使用的是 Fedora,输入下面命令:

sudo dnf install ansible -y

若运行的是 CentOS,你需要为 EPEL 仓库配置额外的包:

sudo yum install epel-release -y

然后再使用 yum 来安装 Ansible:

sudo yum install ansible -y

对于基于 Ubuntu 的系统,可以从 PPA 上安装 Ansible:

sudo apt-get install software-properties-common -y
sudo apt-add-repository ppa:ansible/ansible
sudo apt-get update
sudo apt-get install ansible -y

若你使用的是 macOS,那么推荐通过 Python PIP 来安装:

sudo pip install ansible

对于其他发行版,请参见 Ansible 安装文档

Ansible Inventory

Ansible 使用一个 INI 风格的文件来追踪要管理的服务器,这种文件被称之为 库存清单 Inventory 。默认情况下该文件位于 /etc/ansible/hosts。本文中,我使用示例 2 中所示的 Ansible 库存清单来对所需的主机进行操作(为了简洁起见已经进行了裁剪):

[arch]
nextcloud
prometheus
desktop1
desktop2
vm-host15

[fedora]
netflix

[centos]
conan
confluence
7-repo
vm-server1
gitlab

[ubuntu]
trusty-mirror
nwn
kids-tv
media-centre
nas

[satellite]
satellite

[ocp]
lb00
ocp_dns
master01
app01
infra01

示例 2 : Ansible 主机文件

每个分组由中括号和组名标识(像这样 [group1] ),是应用于一组服务器的任意组名。一台服务器可以存在于多个组中,没有任何问题。在这个案例中,我有根据操作系统进行的分组(archubuntucentosfedora),也有根据服务器功能进行的分组(ocpsatellite)。Ansible 主机文件可以处理比这复杂的多的情况。详细内容,请参阅 库存清单文档

运行命令

将你的 SSH 密钥拷贝到库存清单中所有服务器上后,你就可以开始使用 Ansible 了。Ansible 的一项基本功能就是运行特定命令。语法为:

ansible -a "some command"

例如,假设你想升级所有的 CentOS 服务器,可以运行:

ansible centos -a 'yum update -y'

注意:不是必须要根据服务器操作系统来进行分组的。我下面会提到,Ansible Facts 可以用来收集这一信息;然而,若使用 Facts 的话,则运行特定命令会变得很复杂,因此,如果你在管理异构环境的话,那么为了方便起见,我推荐创建一些根据操作系统来划分的组。

这会遍历 centos 组中的所有服务器并安装所有的更新。一个更加有用的命令应该是 Ansible 的 ping 模块了,可以用来验证服务器是否准备好接受命令了:

ansible all -m ping

这会让 Ansible 尝试通过 SSH 登录库存清单中的所有服务器。在示例 3 中可以看到 ping 命令的部分输出结果。

nwn | SUCCESS => {
    "changed":false,
    "ping":"pong"
}
media-centre | SUCCESS => {
    "changed":false,
    "ping":"pong"
}
nas | SUCCESS => {
    "changed":false,
    "ping":"pong"
}
kids-tv | SUCCESS => {
    "changed":false,
    "ping":"pong"
}
...

示例 3 :Ansible ping 命令输出

运行指定命令的能力有助于完成快速任务(LCTT 译注:应该指的那种一次性任务),但是如果我想在以后也能以同样的方式运行同样的任务那该怎么办呢?Ansible playbooks 就是用来做这个的。

复杂任务使用 Ansible playbooks

Ansible 剧本 playbook 就是包含 Ansible 指令的 YAML 格式的文件。我这里不打算讲解类似 Roles 和 Templates 这些比较高深的内容。有兴趣的话,请阅读 Ansible 文档

在前一章节,我推荐你使用 ssh-copy-id 命令来传递你的 SSH 密钥;然而,本文关注于如何以一种一致的、可重复性的方式来完成任务。示例 4 演示了一种以冥等的方式,即使 SSH 密钥已经存在于目标主机上也能保证正确性的实现方法。

---
- hosts:all
  gather_facts:false
  vars:
    ssh_key:'/root/playbooks/files/laptop_ssh_key'
  tasks:
    - name:copy ssh key
      authorized_key:
        key:"{{ lookup('file',ssh_key) }}"
        user:root

示例 4:Ansible 剧本 “push ssh keys.yaml”

- hosts: 行标识了这个剧本应该在那个主机组上执行。在这个例子中,它会检查库存清单里的所有主机。

gather_facts: 行指明 Ansible 是否去搜索每个主机的详细信息。我稍后会做一次更详细的检查。现在为了节省时间,我们设置 gather_factsfalse

vars: 部分,顾名思义,就是用来定义剧本中所用变量的。在示例 4 的这个简短剧本中其实不是必要的,但是按惯例我们还是设置了一个变量。

最后由 tasks: 标注的这个部分,是存放主体指令的地方。每个任务都有一个 -name:。Ansbile 在运行剧本时会显示这个名字。

authorized_key: 是剧本所使用 Ansible 模块的名字。可以通过命令 ansible-doc -a 来查询 Ansible 模块的相关信息; 不过通过网络浏览器查看 文档 可能更方便一些。authorized\_key 模块 有很多很好的例子可以参考。要运行示例 4 中的剧本,只要运行 ansible-playbook 命令就行了:

ansible-playbook push_ssh_keys.yaml

如果是第一次添加 SSH 密钥,SSH 会提示你输入 root 用户的密码。

现在 SSH 密钥已经传输到服务器中去了,可以来做点有趣的事了。

使用 Ansible 收集信息

Ansible 能够收集目标系统的各种信息。如果你的主机数量很多,那它会特别的耗时。按我的经验,每台主机大概要花个 1 到 2 秒钟,甚至更长时间;然而有时收集信息是有好处的。考虑下面这个剧本,它会禁止 root 用户通过密码远程登录系统:

---
- hosts:all
  gather_facts:true
  vars:
  tasks:
    - name:Enabling ssh-key only root access
      lineinfile:
        dest:/etc/ssh/sshd_config
        regexp:'^PermitRootLogin'
        line:'PermitRootLogin without-password'
      notify:
        - restart_sshd
        - restart_ssh

  handlers:
    - name:restart_sshd
      service:
        name:sshd
        state:restarted
        enabled:true
      when:ansible_distribution == 'RedHat'
    - name:restart_ssh
      service:
        name:ssh
        state:restarted
        enabled:true
      when:ansible_distribution == 'Debian'

示例 5:锁定 root 的 SSH 访问

在示例 5 中 sshd_config 文件的修改是有条件 的,只有在找到匹配的发行版的情况下才会执行。在这个案例中,基于 Red Hat 的发行版与基于 Debian 的发行版对 SSH 服务的命名是不一样的,这也是使用条件语句的目的所在。虽然也有其他的方法可以达到相同的效果,但这个例子很好演示了 Ansible 信息的作用。若你想查看 Ansible 默认收集的所有信息,可以在本地运行 setup 模块:

ansible localhost -m setup |less

Ansible 收集的所有信息都能用来做判断,就跟示例 4 中 vars: 部分所演示的一样。所不同的是,Ansible 信息被看成是内置 变量,无需由系统管理员定义。

更近一步

现在可以开始探索 Ansible 并创建自己的基本了。Ansible 是一个富有深度、复杂性和灵活性的工具,只靠一篇文章不可能就把它讲透。希望本文能够激发你的兴趣,鼓励你去探索 Ansible 的功能。在下一篇文章中,我会再聊聊 Copysystemdserviceaptyumvirt,以及 user 模块。我们可以在剧本中组合使用这些模块,还可以创建一个简单的 Git 服务器来存储这些所有剧本。


via: https://opensource.com/article/17/7/automate-sysadmin-ansible

作者:Steve Ovens 译者:lujun9972 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

Ansible Container 解决了 Dockerfile 的不足,并对容器化项目提供了完整的管理。

 title=

Image by : opensource.com

我喜欢容器,并且每天都使用这个技术。即便如此,容器并不完美。不过,在过去几个月里,一系列项目已经解决了我遇到的一些问题。

我刚开始时,用 Docker 使用容器,这个项目使得这种技术非常流行。除了使用这个容器引擎之外,我学到了怎么去使用 docker-compose 以及怎么去用它管理我的项目。使用它使得我的生产力猛增!一个命令就可以运行我的项目,而不管它有多复杂。因此,我太高兴了。

使用一段时间之后,我发现了一些问题。最明显的问题是创建容器镜像的过程。Docker 工具使用一个定制的文件格式作为生成容器镜像的依据:Dockerfile。这个格式易于学习,并且很短的一段时间之后,你就可以自己制作容器镜像了。但是,一旦你希望进一步掌握它或者考虑到复杂场景,问题就会出现。

让我们打断一下,先去了解一个不同的东西:Ansible 的世界。你知道它吗?它棒极了,是吗?你不这么认为?好吧,是时候去学习一些新事物了。Ansible 是一个允许你通过写一些任务去管理你的基础设施,并在你选择的环境中运行它们的项目。不需要去安装和设置任何的服务;你可以从你的笔记本电脑中很容易地做任何事情。许多人已经接受 Ansible 了。

想像一下这样的场景:你在 Ansible 中,你写了很多的 Ansible 角色 role 剧本 playbook ,你可以用它们去管理你的基础设施,并且你想把它们运用到容器中。你应该怎么做?通过 shell 脚本和 Dockerfile 去写容器镜像定义?听起来好像不对。

来自 Ansible 开发团队的一些人问到这个问题,并且他们意识到,人们每天编写和使用的那些同样的 Ansible 角色和剧本也可以用来制作容器镜像。但是 Ansible 能做到的不止这些 —— 它可以被用于去管理容器化项目的完整生命周期。从这些想法中,Ansible Container 项目诞生了。它利用已有的 Ansible 角色转变成容器镜像,甚至还可以被用于生产环境中从构建到部署的完整生命周期。

现在让我们讨论一下,我之前提到过的在 Dockerfile 环境中的最佳实践问题。这里有一个警告:这将是非常具体且技术性的。出现最多的三个问题有:

1、 在 Dockerfile 中内嵌的 Shell 脚本

当写 Dockerfile 时,你可以指定会由 /bin/sh -c 解释执行的脚本。它类似如下:

RUN dnf install -y nginx

这里 RUN 是一个 Dockerfile 指令,其它的都是参数(它们传递给 shell)。但是,想像一个更复杂的场景:

RUN set -eux; \
    \
# this "case" statement is generated via "update.sh"
    %%ARCH-CASE%%; \
    \
    url="https://golang.org/dl/go${GOLANG_VERSION}.${goRelArch}.tar.gz"; \
    wget -O go.tgz "$url"; \
    echo "${goRelSha256} *go.tgz" | sha256sum -c -; \

这仅是从 golang 官方镜像 中拿来的一段。它看起来并不好看,是不是?

2、 解析 Dockerfile 并不容易

Dockerfile 是一个没有正式规范的新格式。如果你需要在你的基础设施(比如,让构建过程自动化一点)中去处理 Dockerfile 将会很复杂。仅有的规范是 这个代码,它是 dockerd 的一部分。问题是你不能使用它作为一个 library 来使用。最容易的解决方案是你自己写一个解析器,然后祈祷它运行的很好。使用一些众所周知的标记语言不是更好吗?比如,YAML 或者 JSON。

3、 管理困难

如果你熟悉容器镜像的内部结构,你可能知道每个镜像是由 layer 构成的。一旦容器被创建,这些层就使用联合文件系统技术堆叠在一起(像煎饼一样)。问题是,你并不能显式地管理这些层 — 你不能说,“这儿开始一个新层”,你被迫使用一种可读性不好的方法去改变你的 Dockerfile。最大的问题是,必须遵循一套最佳实践以去达到最优结果 — 新来的人在这个地方可能很困难。

Ansible 语言和 Dockerfile 比较

相比 Ansible,Dockerfile 的最大缺点,也是 Ansible 的优点,作为一个语言,Ansible 更强大。例如,Dockerfile 没有直接的变量概念,而 Ansible 有一个完整的模板系统(变量只是它其中的一个特性)。Ansible 包含了很多更易于使用的模块,比如,wait\_for,它可以被用于服务就绪检查,比如,在处理之前等待服务准备就绪。在 Dockerfile 中,做任何事情都通过一个 shell 脚本。因此,如果你想去找出已准备好的服务,它必须使用 shell(或者独立安装)去做。使用 shell 脚本的其它问题是,它会变得很复杂,维护成为一种负担。很多人已经发现了这个问题,并将这些 shell 脚本转到 Ansible。

关于作者

Tomas Tomecek - 工程师、Hacker、演讲者、Tinker、Red Hatter。喜欢容器、linux、开源软件、python 3、rust、zsh、tmux。More about me


via: https://opensource.com/article/17/10/dockerfiles-ansible-container

作者:Tomas Tomecek 译者:qhwdw 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

容器是一个日益流行的开发环境。作为一名开发人员,你可以选择多种工具来管理你的容器。本文将向你介绍 Ansible Container,并展示如何在类似生产环境中运行和测试你的应用程序。

入门

这个例子使用了一个简单的 Flask Hello World 程序。这个程序就像在生产环境中一样由 Apache HTTP 服务器提供服务。首先,安装必要的 docker 包:

sudo dnf install docker

Ansible Container 需要通过本地套接字与 Docker 服务进行通信。以下命令将更改套接字所有者,并将你添加到可访问此套接字的 docker 用户组:

sudo groupadd docker && sudo gpasswd -a $USER docker
MYGRP=$(id -g) ; newgrp docker ; newgrp $MYGRP

运行 id 命令以确保 docker 组在你的组成员中列出。最后,使用 sudo 启用并启动 docker 服务:

sudo systemctl enable docker.service
sudo systemctl start docker.service

设置 Ansible Container

Ansible Container 使你能够构建容器镜像并使用 Ansible playbook 进行编排。该程序在一个 YAML 文件中描述,而不是使用 Dockerfile,列出组成容器镜像的 Ansible 角色。

不幸的是,Ansible Container 在 Fedora 中没有 RPM 包可用。要安装它,请使用 python3 虚拟环境模块。

mkdir ansible-container-flask-example
cd ansible-container-flask-example
python3 -m venv .venv
source .venv/bin/activate
pip install ansible-container[docker]

这些命令将安装 Ansible Container 及 Docker 引擎。 Ansible Container 提供三种引擎:Docker、Kubernetes 和 Openshift。

设置项目

现在已经安装了 Ansible Container,接着设置这个项目。Ansible Container 提供了一个简单的命令来创建启动所需的所有文件:

ansible-container init

来看看这个命令在当前目录中创建的文件:

  • ansible.cfg
  • ansible-requirements.txt
  • container.yml
  • meta.yml
  • requirements.yml

该项目仅使用 container.yml 来描述程序服务。有关其他文件的更多信息,请查看 Ansible Container 的入门文档。

定义容器

如下更新 container.yml

version: "2"
settings:
  conductor:
    # The Conductor container does the heavy lifting, and provides a portable
    # Python runtime for building your target containers. It should be derived
    # from the same distribution as you're building your target containers with.
    base: fedora:26
    # roles_path:   # Specify a local path containing Ansible roles
    # volumes:      # Provide a list of volumes to mount
    # environment:  # List or mapping of environment variables

  # Set the name of the project. Defaults to basename of the project directory.
  # For built services, concatenated with service name to form the built image name.
  project_name: flask-helloworld

services: 
  # Add your containers here, specifying the base image you want to build from.
  # To use this example, uncomment it and delete the curly braces after services key.
  # You may need to run `docker pull ubuntu:trusty` for this to work.
  web:
    from: "fedora:26"
    roles: 
      - base
    ports:
      - "5000:80"
    command: ["/usr/bin/dumb-init", "httpd", "-DFOREGROUND"]
    volumes:
      - $PWD/flask-helloworld:/flaskapp:Z

conductor 部分更新了基本设置以使用 Fedora 26 容器基础镜像。

services 部分添加了 web 服务。这个服务使用 Fedora 26,后面有一个名为 base 的角色。它还设置容器和主机之间的端口映射。Apache HTTP 服务器为容器的端口 80 上的 Flask 程序提供服务,该容器重定向到主机的端口 5000。然后这个文件定义了一个卷,它将 Flask 程序源代码挂载到容器中的 /flaskapp 中。

最后,容器启动时运行 command 配置。这个例子中使用 dumb-init,一个简单的进程管理器并初始化系统启动 Apache HTTP 服务器。

Ansible 角色

现在已经设置完了容器,创建一个 Ansible 角色来安装并配置 Flask 程序所需的依赖关系。首先,创建 base 角色。

mkdir -p roles/base/tasks
touch roles/base/tasks/main.yml

现在编辑 main.yml ,它看起来像这样:

---
- name: Install dependencies 
  dnf: pkg={{item}} state=present
  with_items:
    - python3-flask
    - dumb-init
    - httpd
    - python3-mod_wsgi

- name: copy the apache configuration
  copy:
    src: flask-helloworld.conf
    dest: /etc/httpd/conf.d/flask-helloworld.conf
    owner: apache
    group: root
    mode: 655

这个 Ansible 角色是简单的。首先它安装依赖关系。然后,复制 Apache HTTP 服务器配置。如果你对 Ansible 角色不熟悉,请查看角色文档

Apache HTTP 配置

接下来,通过创建 flask-helloworld.conf 来配置 Apache HTTP 服务器:

$ mkdir -p roles/base/files
$ touch roles/base/files/flask-helloworld.conf

最后将以下内容添加到文件中:

<VirtualHost *>
    ServerName example.com

    WSGIDaemonProcess hello_world user=apache group=root
    WSGIScriptAlias / /flaskapp/flask-helloworld.wsgi

    <Directory /flaskapp>
        WSGIProcessGroup hello_world
        WSGIApplicationGroup %{GLOBAL}
    Require all granted
    </Directory>
</VirtualHost>

这个文件的重要部分是 WSGIScriptAlias。该指令将脚本 flask-helloworld.wsgi 映射到 /。有关 Apache HTTP 服务器和 mod\_wsgi 的更多详细信息,请阅读 Flask 文档

Flask “hello world”

最后,创建一个简单的 Flask 程序和 flask-helloworld.wsgi 脚本。

mkdir flask-helloworld
touch flask-helloworld/app.py
touch flask-helloworld/flask-helloworld.wsgi

将以下内容添加到 app.py

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello World!"

然后编辑 flask-helloworld.wsgi ,添加这个:

import sys
sys.path.insert(0, '/flaskapp/')

from app import app as application

构建并运行

现在是时候使用 ansible-container buildansible-container run 命令来构建和运行容器。

ansible-container build

这个命令需要一些时间来完成,所以要耐心等待。

ansible-container run

你现在可以通过以下 URL 访问你的 flask 程序: http://localhost:5000/

结论

你现在已经看到如何使用 Ansible Container 来管理、构建和配置在容器中运行的程序。本例的所有配置文件和源代码在 Pagure.io 上。你可以使用此例作为基础来开始在项目中使用 Ansible Container。


via: https://fedoramagazine.org/build-test-applications-ansible-container/

作者:Clement Verna 译者:geekpi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出