考试题型
- 选择题 30 分
- 简答题 包含进程同步编程题 20 分
- 综合题 ansible 20 分
复习大纲
第 2 章 基础运维技能
(1)列举 3 种常用字符编码,简述怎样在 str 和 bytes 之间进行编码和解码。
常用字符编码:ASCII
GBK
Unicode(UTF-8,UTF-16,UTF-32)
str编码bytes:str.encode()
bytes解码str:bytes.decode()
编码和解码时要指定类型,例如:
# 编码
text = "Hello, 你好"
encoded_bytes = text.encode("utf-8")
# 解码
bytes_data = b'Hello, \xe4\xbd\xa0\xe5\xa5\xbd'
decoded_text = bytes_data.decode("utf-8")
(2)简述文件操作的流程,简述 3 个常用的文件操作方法。
- 打开文件,得到一个句柄并赋值给一个变量:使用内置函数
open()
打开文件,指定文件路径和操作模式。 - 通过句柄对文件进行操作:根据需要进行读取或写入文件内容。
- 关闭文件:使用
close()
方法关闭文件,释放资源。
常用的文件操作方法:
read(size=-1)
:从文件中读取指定大小的内容,若不指定大小则读取全部内容。readline()
:逐行读取文件内容。readlines()
:将文件内容按行读取,并返回一个包含所有行的列表。write(string)
:将字符串写入文件。writelines(lines)
:将包含多行文本的列表写入文件。seek(offset[, whence])
:改变当前文件指针的位置,用于定位读写位置。
(3)open 函数的 mode 参数表示什么?简述 mode 参数的 4 个常用取值。
mode 参数指的是打开文件的模式,用于指定文件的打开方式和操作类型
常见的取值:
"r"
:只读模式(默认)。以只读模式打开文件,你只能读取文件的内容,不能进行写入操作。如果文件不存在,会引发FileNotFoundError
异常。"w"
:写入模式。以写入模式打开文件,如果文件存在,则会截断(清空)文件的内容,然后你可以向文件中写入新的内容。如果文件不存在,会创建一个新文件。"a"
:追加模式。以追加模式打开文件,你可以将新的内容追加到文件的末尾,而不影响文件原有的内容。如果文件不存在,会创建一个新文件。"x"
:排他性创建模式。以排他性创建模式打开文件,只有当文件不存在时才能成功打开,否则会引发FileExistsError
异常。"b"
:二进制模式。以二进制模式打开文件,适用于处理二进制文件,如图像、音频或视频文件。在其他模式后添加"b"
表示以二进制模式打开文件,例如"rb"
表示以二进制只读模式打开文件。"t"
:文本模式(默认)。以文本模式打开文件,可以处理文本文件的内容。这是默认的模式,通常不需要显式指定。'+'
:读写模式,可同时读写文件。
(4)阐述配置文件的格式,解析配置文件主要用到哪个模块的哪个类?简述该 类的 3 个常用方法。
配置文件的格式可以使用常见的文件格式,如 INI 文件、JSON 文件、YAML 文件等。其中,INI 文件是一种常见的格式,以键值对的形式存储配置信息。
解析配置文件常用到的模块是 configparser
,其中的 ConfigParser
类提供了解析和处理配置文件的功能。
ConfigParser
类的常用方法:
read(filename)
:读取配置文件。sections()
:返回所有的配置节。options(section)
:返回指定配置节的所有选项。get(section, option)
:获取指定配置节和选项的值。
(5)简述 json 模块中解析 json 常用的 4 个函数。
json 模块中常用的四个函数:
json.loads(s)
:将 JSON 字符串解析为 Python 对象。json.dumps(obj)
:将 Python 对象序列化为 JSON 字符串。json.load(fp)
:从文件中读取 JSON 数据并解析为 Python 对象。json.dump(obj, fp)
:将 Python 对象序列化为 JSON 数据并写入文件。
(6)简述 xmltodict 如何处理 xml 数据。
xmltodict 是一个用于将 XML 数据解析为 Python 字典的模块。
使用 xmltodict 处理 XML 数据的流程:
- 将 XML 数据转换为 Python 字典:使用
xmltodict.parse()
方法,将 XML 数据作为参数传入,得到一个 Python 字典表示的数据结构。 - 处理 Python 字典中的数据:可以通过索引、迭代等方式获取和处理字典中的数据。
例如,将 XML 数据解析为 Python 字典:
import xmltodict
xml_data = """
<book>
<title>Python Programming</title>
<author>John Doe</author>
</book>
"""
data_dict = xmltodict.parse(xml_data)
(7)如何安装 psutil 模块,简述使用 psutil 模块可以监控系统的那些信息。
使用pip包管理器安装,执行如下命令:
pip install psutil
psutil 模块可以用于监控系统的各种信息,包括:
- CPU 使用情况:可以获取 CPU 的使用率、核心数等信息。
cpu_percent = psutil.cpu_percent() # 获取 CPU 使用百分比
cpu_count = psutil.cpu_count() # 获取 CPU 核心数量
cpu_stats = psutil.cpu_stats() # 获取 CPU 统计信息
- 内存使用情况:可以获取内存的使用率、总量、可用量等信息。
memory = psutil.virtual_memory() # 获取虚拟内存使用情况
memory_percent = memory.percent # 获取内存使用百分比
memory_total = memory.total # 获取内存总量
memory_used = memory.used # 获取已使用的内存量
- 磁盘使用情况:可以获取磁盘的使用率、总空间、可用空间等信息。
disk_usage = psutil.disk_usage('/') # 获取根目录磁盘使用情况
disk_percent = disk_usage.percent # 获取磁盘使用百分比
disk_total = disk_usage.total # 获取磁盘总量
disk_used = disk_usage.used # 获取已使用的磁盘量
- 网络使用情况:可以获取网络的连接数、网络速度等信息。
network_stats = psutil.net_io_counters() # 获取网络统计信息
bytes_sent = network_stats.bytes_sent # 获取发送的字节数
bytes_received = network_stats.bytes_recv # 获取接收的字节数
(8)阐述使用 watchdog 监控指定目录/文件变化的工作原理。
watchdog 是一个 Python 库,用于监控文件系统的变化。
watchdog 监控指定目录/文件变化的工作原理:
- 创建一个
Observer
对象。 - 创建一个
EventHandler
对象,继承FileSystemEventHandler
类,重写需要处理的文件系统事件方法。 - 将
EventHandler
对象注册到Observer
对象中。 - 启动
Observer
对象,开始监控文件系统的变化。
当目录/文件发生变化时,Observer
会通知注册的 EventHandler
对象,并调用相应的方法进行处理。
(9)在 subprocess.Popen 类构造函数的参数中,stdin,stdout,stderr 的默认取值 是什么?表示什么意思?如何将子进程的输出传给父进程处理?
在 subprocess.Popen
类构造函数的参数中,stdin
、stdout
和 stderr
的默认取值分别是 None
,表示子进程的标准输入、标准输出和标准错误输出被重定向到 subprocess.PIPE
。
subprocess.PIPE
表示创建一个管道,可以通过管道与子进程进行输入和输出交互。
如果需要将子进程的输出传给父进程处理,可以使用 communicate()
方法,该方法会等待子进程结束并返回子进程的输出。
例如:
import subprocess
process = subprocess.Popen(["command", "arg1", "arg2"], stdout=subprocess.PIPE)
output, error = process.communicate()
print(output.decode("utf-8"))
(10)简述日志的作用,通过日志记录事件时,通常需要记录事件的哪些方面?
日志的作用是记录程序运行时的关键事件和信息,方便排查问题和了解程序的运行状态。
通过日志记录事件时,通常需要记录以下方面的信息:
- 时间戳:记录事件发生的时间。
- 日志级别:表示事件的严重程度,如 DEBUG、INFO、WARNING、ERROR、CRITICAL 等。
- 日志内容:具体的事件描述和相关信息。
日志还可以包含其他信息,如线程号、模块名、函数名等,以便更好地定位和分析问题。
(11)在 logging 模块中,日志的级别有哪些?他们如何排序?
在 logging 模块中,日志的级别从低到高依次是:
- DEBUG:调试级别的日志信息,最低级别。
- INFO:用于确认程序按预期运行的信息级别。
- WARNING:表示警告信息,可能会导致问题的情况。
- ERROR:表示错误信息,程序可能会出现错误但仍能继续运行。
- CRITICAL:表示严重的错误信息,可能会导致程序无法继续运行的情况,最高级别。
日志级别是可以设置的,低于设置级别的日志信息将被忽略。
(12)在 logging 模块中,什么是记录器,处理器和格式化器,他们之间是什么 关系?掌握相关的设置语句。
在 logging 模块中,记录器(Logger)、处理器(Handler)和格式化器(Formatter)是三个核心概念。
- 记录器(Logger):用于记录日志信息的对象。可以创建多个记录器,根据需要进行配置和使用。
- 处理器(Handler):负责将日志记录发送到指定的位置,如控制台、文件、网络等。一个记录器可以绑定多个处理器。
- 格式化器(Formatter):定义日志的输出格式,包括时间、级别、内容等。可以自定义格式,或使用预定义的格式。
记录器、处理器和格式化器之间的关系:
- 记录器可以通过
addHandler()
方法添加处理器。 - 处理器可以通过
setFormatter()
方法设置格式化器。 - 记录器可以通过
setLevel()
方法设置日志级别。
例如,创建一个记录器并添加处理器:
import logging
logger = logging.getLogger("my_logger")
handler = logging.StreamHandler() # 创建一个处理器,输出日志到控制台
formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s") # 创建一个格式化器
handler.setFormatter(formatter) # 设置处理器的格式化器
logger.addHandler(handler) # 添加处理器到记录器
(13)使用 pyftpdlib 模块一行命令快速搭建 FTP 服务器可以进行哪些设置?请 列举三个使用 pyftpdlib API 编程比一行命令更丰富的功能。
- 指定 IP 地址和端口号。
- 设置用户名和密码。
- 指定 FTP 根目录。
使用 pyftpdlib API 编程可以实现更丰富的功能,如:
- 自定义权限控制:可以根据用户、目录等条件进行权限控制。
- 文件上传和下载:可以实现文件的上传和下载功能。
- 日志记录和事件处理:可以记录 FTP 服务器的日志并处理特定事件。
(14)简述编程实现邮件发送的步骤,并具体说明用到了哪些类或方法。
- 导入
smtplib
模块,创建 SMTP 连接。 - 登录邮件服务器,使用账号和密码进行身份验证。
- 创建邮件内容,设置发件人、收件人、主题和正文等。
- 发送邮件,调用
sendmail()
方法发送邮件。 - 关闭 SMTP 连接。
常用的类或方法:
smtplib.SMTP
:创建 SMTP 连接的类。SMTP.login(user, password)
:登录邮件服务器。SMTP.sendmail(from_addr, to_addrs, msg)
:发送邮件。MIMEText
:创建邮件正文的类。MIMEMultipart
:创建带附件的邮件的类。
例如,发送简单文本邮件的示例代码:
import smtplib
from email.mime.text import MIMEText
# 邮件内容
msg = MIMEText("Hello, this is a test email.", "plain")
# 发件人和收件人
msg["From"] = "sender@example.com"
msg["To"] = "recipient@example.com"
msg["Subject"] = "Test Email"
# SMTP 连接
smtp_server = smtplib.SMTP("smtp.example.com", 587)
smtp_server.starttls()
# 登录邮箱
smtp_server.login("username", "password")
# 发送邮件
smtp_server.sendmail("sender@example.com", "recipient@example.com", msg.as_string())
# 关闭连接
smtp_server.quit()
第 3 章 实战多进程
(1)multiprocessing 模块实现进程同步的类及其主要的方法。
Lock
:进程锁,用于实现进程间的互斥访问。常用的方法有acquire()
获取锁,release()
释放锁。Event
:事件对象,用于进程间的通信和同步。常用的方法有set()
设置事件为真,clear()
清除事件为假,wait()
等待事件被设置。Condition
:条件对象,用于实现复杂的进程同步。常用的方法有acquire()
获取条件锁,release()
释放条件锁,wait()
等待条件,notify()
通知等待的进程,notify_all()
通知所有等待的进程。Semaphore
:信号量对象,用于控制进程的访问数量。常用的方法有acquire()
获取信号量,release()
释放信号量。
(2)multiprocessing 模块实现进程通信的类及其主要的方法。
Queue
:进程安全的队列,用于进程间的数据通信。常用的方法有put()
向队列中放入数据,get()
从队列中获取数据。Pipe
:进程间的管道,用于双向通信。常用的方法有send()
向管道发送数据,recv()
接收管道中的数据。
第 4 章 实战多线程
(1)多进程和多线程分别适用于什么类型的作业。
- 多进程适用于 CPU 密集型任务,即任务需要大量的 CPU 运算资源。
- 多线程适用于 I/O 密集型任务,即任务主要涉及到 I/O 操作,如读写文件、网络请求等。
(2)threading 模块实现线程同步的类及其主要的方法。
Lock
:线程锁,用于实现线程间的互斥访问。常用的方法有acquire()
获取锁,release()
释放锁。Event
:事件对象,用于线程间的通信和同步。常用的方法有set()
设置事件为真,clear()
清除事件为假,wait()
等待事件被设置。Condition
:条件对象,用于实现复杂的线程同步。常用的方法有acquire()
获取条件锁,release()
释放条件锁,wait()
等待条件,notify()
通知等待的线程,notify_all()
通知所有等待的线程。Semaphore
:信号量对象,用于控制线程的访问数量。常用的方法有acquire()
获取信号量,release()
释放信号量。
(3)threading 模块实现多线程通信的类及其主要的方法。
Queue
:线程安全的队列,用于线程间的数据通信。常用的方法有
put()
向队列中放入数据
get()
从队列中获取数据。
第 5 章 实战协程
(1)协程的概念。
协程是一种用户态的轻量级线程,可以在单线程中实现多任务的并发执行。协程通过自身的控制,可以在任务执行过程中主动让出CPU,以便执行其他任务,从而实现高效的并发编程。
(2)进程、线程、协程的对比。
- 进程:是操作系统分配资源的基本单位,具有独立的地址空间和系统资源,进程间切换开销较大。
- 线程:是进程的执行单位,多个线程共享同一进程的资源,线程间切换开销较小,但需要由操作系统进行调度。
- 协程:是用户态的轻量级线程,由用户代码控制执行流程,切换开销极小,可以在单线程中实现高并发。
(3)协程应用场景。
协程适用于 I/O 密集型任务,特别是需要频繁进行网络请求、数据库操作等阻塞操作的场景。使用协程可以充分利用 CPU 时间,提高程序的并发性能。
第 6 章 自动化运维工具 ansible
(1)ansible 实现主机管理的安装要求。
- 控制节点(管理端):Python 2(2.7 及以上)或 Python 3,SSH 客户端,Ansible 软件包。
- 托管节点(被管理端):SSH 服务,Python 2 或 Python 3。
(2)如何定义主机清单 Inventory 文件?
主机清单 Inventory 文件是 Ansible 的一项重要配置,用于指定被管理的主机。
主机清单文件可以采用 INI 格式或 YAML 格式进行定义。在 INI 格式中,可以按组织结构定义主机和组,如:
[web]
web1 ansible_host=192.168.1.10
web2 ansible_host=192.168.1.11
[db]
db1 ansible_host=192.168.1.20
在 YAML 格式中,可以按字典方式定义主机和组,如:
all:
hosts:
web1:
ansible_host: 192.168.1.10
web2:
ansible_host: 192.168.1.11
children:
web:
hosts:
web1:
web2:
db:
hosts:
db1:
(3)实现 ansible 免密登录的步骤。
- 生成 SSH 密钥对:在控制节点上执行
ssh-keygen
命令生成密钥对。 - 分发公钥到被管理的主机:使用
ssh-copy-id
命令将公钥复制到被管理的主机上,或手动将公钥内容添加到被管理主机的~/.ssh/authorized_keys
文件中。 - 验证免密登录:使用
ssh
命令测试从控制节点到被管理主机的免密登录是否生效。
(4)Ansible ad-hoc 模式的常用命令。
Ansible ad-hoc 模式是一种临时执行命令的方式,常用于快速执行一些简单的任务。
常见的 ad-hoc 命令示例:
- 执行命令:
ansible <hosts> -m <module> -a "<arguments>"
- 拷贝文件:
ansible <hosts> -m copy -a "src=<source_file> dest=<destination_file>"
- 安装软件包:
ansible <hosts> -m yum -a "name=<package_name> state=present"
- 重启服务:
ansible <hosts> -m service -a "name=<service_name> state=restarted"
(5)YMAL 文件格式。
YAML(YAML Ain’t Markup Language)是一种人类可读的数据序列化格式,常用于配置文件和数据交换。
YAML 使用缩进和冒号来表示层级关系,支持列表、字典和基本数据类型。
示例:
web:
- host: web1
ip: 192.168.1.10
- host: web2
ip: 192.168.1.11
db:
- host: db1
ip: 192.168.1.20
(6)会编写简单的 playbook。
Ansible playbook 是用于定义和执行多个任务的配置文件。
一个简单的 playbook 示例:
- name: Install and start Nginx
hosts: web
tasks:
- name: Install Nginx
yum:
name: nginx
state: present
- name: Start Nginx service
service:
name: nginx
state: started
第 7、8 章 定时任务模块 APScheduler 和执行远程命令(Paramiko)
(1)简述 APScheduler 的功能。
APScheduler 是一个用于在 Python 应用中执行定时任务的库。它提供了灵活的调度方式,支持多种调度器(Scheduler)和触发器(Trigger),可以执行定时任务、周期性任务和延迟任务。APScheduler 可以与各种 Python 框架和应用程序集成,帮助开发者方便地实现定时任务调度功能。
(2)简述 Paramiko 的功能。
Paramiko 是一个用于在 Python 中执行远程命令和传输文件的模块。它实现了 SSH2 协议,可以通过 SSH 连接远程服务器,并执行命令、上传下载文件。Paramiko 提供了高级的 SSH 客户端接口,支持远程命令执行、SFTP 文件传输和 SSH 通道的建立。它可以在 Python 程序中实现远程服务器的管理和操作。
第 9 章 分布式任务队列 Celery
(1)Celery 的功能有哪些?
- 分布式任务调度:Celery 提供了分布式的任务调度功能,可以将任务分发到多个工作者(Worker)进行执行,实现并行处理和负载均衡。
- 异步执行:Celery 支持异步执行任务,可以将任务提交给 Celery 队列,而不会阻塞主线程的执行,提高程序的响应性能。
- 定时任务:Celery 可以设置定时任务,根据指定的时间表执行任务,支持多种调度方式。
- 结果追踪:Celery 可以追踪任务的执行结果,包括成功、失败和超时等状态,方便任务的监控和处理。
- 错误处理:Celery 提供了错误处理机制,可以捕获和处理任务执行过程中的异常,保证任务的可靠性和稳定性。
(2)Celery 如何实现不同的队列执行不同的任务?
Celery 通过使用任务队列来实现任务的分发和执行,可以配置多个队列,并根据任务的类型或其他条件将任务分配到不同的队列中。
在 Celery 的配置文件中,可以通过 CELERY_QUEUES
参数定义多个队列,并为每个队列指定名称、路由规则和优先级。
示例配置:
CELERY_QUEUES = (
Queue('default', routing_key='default'),
Queue('tasks', routing_key='tasks'),
)
CELERY_ROUTES = {
'myapp.tasks.default_task': {'queue': 'default', 'routing_key': 'default'},
'myapp.tasks.task1': {'queue': 'tasks', 'routing_key': 'tasks'},
}
上述配置定义了两个队列:default
和 tasks
,并分别指定了路由规则。根据任务的函数名称,可以将任务分配到相应的队列中。例如,default_task
函数的任务会被分配到 default
队列,task1
函数的任务会被分配到 tasks
队列。通过这种方式,可以实现不同队列执行不同的任务。
附加内容
进程同步
在 Python 中进行进程同步编程,可以使用多种方法,包括锁、条件变量、信号量等。下面介绍一些常用的进程同步方法:
锁(Lock):
锁是一种最基本的同步机制,用于确保在任何给定时间只有一个进程可以访问共享资源。Python 提供了 multiprocessing
模块中的 Lock
类来实现锁机制。
from multiprocessing import Process, Lock
def worker(lock, data):
lock.acquire()
try:
# 访问共享资源的代码
print("Worker:", data)
finally:
lock.release()
if __name__ == '__main__':
lock = Lock()
processes = []
for i in range(5):
p = Process(target=worker, args=(lock, i))
processes.append(p)
p.start()
for p in processes:
p.join()
Event
是一种简单的同步原语,可以用于线程或进程之间的事件通知。
下面是使用 Event
实现进程同步通信的示例:
from multiprocessing import Process, Event
def worker(event, data):
event.wait() # 等待事件触发
print("Worker:", data)
if __name__ == '__main__':
event = Event()
processes = []
for i in range(5):
p = Process(target=worker, args=(event, i))
processes.append(p)
p.start()
# 触发事件,通知所有进程可以开始工作
event.set()
for p in processes:
p.join()
条件变量(Condition):
条件变量用于在多个进程之间实现复杂的同步和通信。Python 中的 multiprocessing
模块提供了 Condition
类来实现条件变量。
from multiprocessing import Process, Condition
def producer(condition):
with condition:
print("Producer: Producing item...")
# 生产项目的代码
condition.notify() # 通知消费者
condition.wait() # 等待消费者消费
def consumer(condition):
with condition:
condition.wait() # 等待生产者生产
print("Consumer: Consuming item...")
# 消费项目的代码
condition.notify() # 通知生产者
if __name__ == '__main__':
condition = Condition()
p1 = Process(target=producer, args=(condition,))
p2 = Process(target=consumer, args=(condition,))
p1.start()
p2.start()
p1.join()
p2.join()
信号量(Semaphore):
信号量用于控制对共享资源的访问数量。Python 的 multiprocessing
模块提供了 Semaphore
类来实现信号量。
from multiprocessing import Process, Semaphore
def worker(semaphore, data):
semaphore.acquire()
try:
# 访问共享资源的代码
print("Worker:", data)
finally:
semaphore.release()
if __name__ == '__main__':
semaphore = Semaphore(2) # 设置允许的进程数
processes = []
for i in range(5):
p = Process(target=worker, args=(semaphore, i))
processes.append(p)
p.start()
for p in processes:
p.join()
这些是在 Python 中进行进程同步编程的一些常用方法。根据具体情况选择适合的同步机制,并使用适当的同步原语来保护共享资源的访问。
Ansible
示例
下面是一个示例 Playbook,演示了如何进行用户管理、文件管理以及 LNMP(Linux + Nginx + MySQL + PHP)的安装和配置等方面操作:
---
- name: Network Operations Final Exam
hosts: web_servers
become: true
tasks:
- name: Create user
user:
name: john
password: "{{ 'password' | password_hash('sha512') }}"
state: present
- name: Copy SSH public key
authorized_key:
user: john
key: "{{ lookup('file', '/path/to/public_key.pub') }}"
- name: Ensure Nginx is installed
apt:
name: nginx
state: present
- name: Copy Nginx configuration file
copy:
src: nginx.conf
dest: /etc/nginx/nginx.conf
owner: root
group: root
mode: '0644'
notify: restart nginx
- name: Install MySQL and PHP packages
apt:
name: "{{ item }}"
state: present
with_items:
- mysql-server
- php-fpm
- php-mysql
- name: Configure MySQL root password
debconf:
name: mysql-server
question: 'mysql-server/root_password'
value: 'root_password'
vtype: password
- name: Copy PHP configuration file
template:
src: php.ini.j2
dest: /etc/php/7.4/fpm/php.ini
owner: root
group: root
mode: '0644'
- name: Start and enable Nginx service
service:
name: nginx
state: started
enabled: true
- name: Start and enable PHP-FPM service
service:
name: php7.4-fpm
state: started
enabled: true
handlers:
- name: restart nginx
service:
name: nginx
state: restarted
Playbook 编写步骤
编写 Ansible Playbook 可以遵循以下步骤:
创建一个新的 YAML 文件,例如 playbook.yml
。
在文件中定义 Playbook 的基本结构,包括主机、远程用户、变量等信息。
---
- name: My Playbook
hosts: web_servers
remote_user: ansible
become: true
vars:
var1: value1
var2: value2
name
是 Playbook 的名称,可以任意取名。hosts
定义了 Playbook 执行的目标主机或主机组。remote_user
是用于远程连接的用户名。become: true
表示在执行任务时切换为超级用户(例如sudo
)。
在 Playbook 中添加任务(tasks)。每个任务都是一个操作单元,用于在目标主机上执行特定的操作。
---
- name: My Playbook
hosts: web_servers
remote_user: ansible
become: true
vars:
var1: value1
var2: value2
tasks:
- name: Task 1
<module_name>:
<module_arguments>
- name: Task 2
<module_name>:
<module_arguments>
name
是任务的名称,可以任意取名。<module_name>
是要执行的 Ansible 模块的名称,例如apt
、copy
、service
等。<module_arguments>
是模块的参数,用于指定模块的具体行为。
可以根据需要为任务添加条件、循环、变量等其他功能。这些功能可以通过 Ansible 提供的模块和语法来实现。
---
- name: My Playbook
hosts: web_servers
remote_user: ansible
become: true
vars:
var1: value1
var2: value2
tasks:
- name: Task 1
<module_name>:
<module_arguments>
when: <condition>
- name: Task 2
<module_name>:
<module_arguments>
loop: "{{ items }}"
vars:
var3: "{{ item }}"
when
关键字用于指定任务执行的条件。只有满足条件时,任务才会执行。loop
关键字用于指定循环的迭代器。vars
关键字用于定义任务级别的变量。
保存并运行 Playbook。
ansible-playbook playbook.yml
在运行 Playbook 时,Ansible 会连接到目标主机并执行每个任务。你可以在终端中查看执行结果,并根据需要进行调试和修改。