1. StackStorm概述

1.1 StackStorm介绍

• StackStorm是一个开源的事件驱动自动化平台，它允许开发者和系统管理员自动化IT和网络操作。StackStorm结合了IT运维、DevOps和网络安全团队的需求，提供了一个集中式的工作流自动化解决方案，包括事件响应、运行书自动化、配置管理和编排。

• StackStorm 有助于自动执行常见的操作模式。一些例子是：

  • 便于故障排除 - 触发 Nagios、Sensu、New 捕获的系统故障 Relic 和其他监控系统，在物理节点上运行一系列诊断检查， OpenStack 或 Amazon 实例，以及应用程序组件，并将结果发布到共享的 通信上下文，例如 Slack 或 JIRA。

  • 自动修复 - 识别和验证 OpenStack 计算上的硬件故障 节点，正确撤离实例并向管理员发送电子邮件以了解可能的停机时间，但如果 任何事情都会出错 - 冻结工作流并调用 PagerDuty 来唤醒人类。

  • 持续部署 - 使用 Jenkins 构建和测试，预置新的 AWS 集群，开启 负载均衡器的一些流量，以及基于 NewRelic 应用的前滚或后滚 性能数据。

• StackStorm 可帮助您将这些模式和其他操作模式组合为规则、工作流或操作。 这些规则和工作流 - StackStorm 平台中的内容 - 被存储为代码，这些代码 意味着它们支持您现在用于代码开发的相同协作方法。

1.2 StackStorm的主要特点

• 事件驱动：能够响应来自各种源的事件，包括监控系统、日志、时间触发等。

• 集成性：可以与多种工具和系统集成，例如Ansible、Puppet、Docker、Kubernetes等。

• 工作流：使用YAML或Python编写工作流，实现任务的自动化和编排。

• API驱动：提供REST API，允许通过编程方式触发和控制自动化流程。

• 社区支持：作为一个开源项目，StackStorm拥有活跃的社区，提供持续的更新和支持。

1.3 StackStorm工作原理

• StackStorm 通过包含传感器和操作的可扩展适配器集插入环境。

  • 传感器（Sensors）：

    • 传感器是 Python 插件，用于与外部系统进行入站或出站集成。

    • 它们可以接收或监视事件，并触发 StackStorm 中的触发器。

  • 触发器（Triggers）：

    • 触发器是外部事件在 StackStorm 中的表示。

    • 它们可以是通用的（如计时器、webhooks）或集成的（如Sensu警报、JIRA问题更新）。

    • 新的触发器类型可以通过编写传感器插件来定义。

  • 操作（Actions）：

    • 操作是 StackStorm 的出站集成，可以是通用操作（如SSH、REST调用）、集成操作（如OpenStack、Docker、Puppet）或自定义操作。

    • 操作可以是 Python 插件或任何脚本，通过添加元数据被集成到 StackStorm 中。

    • 操作可以通过 CLI、API 或作为规则和工作流的一部分被调用。

  • 规则（Rules）：

    • 规则将触发器映射到操作或工作流。

    • 它们应用匹配条件并传递触发有效载荷以执行操作输入。

  • 工作流（Workflows）：

    • 工作流将操作组合成更复杂的自动化任务。

    • 它们定义操作的顺序、过渡条件，并传递数据。

    • 工作流可以在 Action 库中手动调用，也可以由规则触发。

  • 包（Packs）：

    • 包是内容部署的单元，简化了 StackStorm 的管理和共享。

    • 它们通过将集成（触发器和操作）和自动化（规则和工作流）进行分组来插入内容。

    • StackStorm Exchange 提供越来越多的包，用户也可以创建自己的包并在 Github 上分享或提交到 StackStorm Exchange。

  • 审计跟踪（Audit Trail）：

    • StackStorm 记录和存储手动或自动操作执行的审计跟踪。

    • 审计日志包含触发上下文和执行结果的详细信息，并可以与外部日志记录和分析工具集成（如LogStash、Splunk、statsd、syslog）。

  • 架构（Architecture）：

    • StackStorm 采用模块化架构，由松散耦合的服务组件组成。

    • 这些组件通过消息总线进行通信，并可以水平扩展以支持大规模自动化。

    • StackStorm 提供 Web UI、CLI 客户端、REST API 和 Python 客户端绑定，以方便开发和操作。

2. StackStorm安装部署

2.1 基于RHEL 7/CentOS 7

2.1.1 系统要求

• StackStorm 需要 Ubuntu、RHEL、RockyLinux 或 CentOS Linux。任何其他 Linux 发行版都不支持它。 下表列出了受支持的 Linux 版本，以及 Vagrant Boxes 和 Amazon AWS 我们用于测试的实例。

Linux (64-bit)	Vagrant Box	Amazon AWS AMI
Ubuntu 18.04	bento/ubuntu-18.04	Ubuntu Server 18.04 LTS Bionic
Ubuntu 20.04	bento/ubuntu-20.04	Ubuntu Server 20.04 LTS Focal
RHEL 8 / RockyLinux 8	bento/rockylinux-8.5	Red Hat Enterprise Linux (RHEL) 8 (HVM)
RHEL 7 / CentOS 7	bento/centos-7.4	Red Hat Enterprise Linux (RHEL) 7.2 (HVM)

• 测试和部署 StackStorm 的建议最小大小：

测试	生产
双 CPU	四核 CPU
2GB内存	>16GB 内存
10GB存储空间	40GB存储空间

• 默认情况下，StackStorm 和相关服务使用以下 TCP 端口：

服务	端口	备注
nginx	80, 443	Web服务器
mongodb	27017	数据库
rabbitmq	4369, 5672, 25672	消息队列
redis	6379	缓存数据库
zookeeper	2181, 2888, 3888	分布式协调服务
st2auth	9100	StackStorm认证服务
st2api	9101	StackStorm API服务
st2stream	9102	StackStorm流服务

如果任何其他服务当前正在使用这些端口，StackStorm 可能无法正确安装或运行。

2.1.2 调整SELinux

[root@StackStorm ~]# getenforce 
Disabled 

2.1.3 安装环境依赖包

2.1.3.1 安装 MongoDB、RabbitMQ 和 Redis

• [root@StackStorm ~]# yum -y install https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
  
  # Add key and repo for the latest stable MongoDB (4.0)
  [root@StackStorm ~]# rpm --import https://www.mongodb.org/static/pgp/server-4.0.asc
  [root@StackStorm ~]# bash -c "cat <<EOT > /etc/yum.repos.d/mongodb-org-4.repo
  [mongodb-org-4]
  name=MongoDB Repository
  baseurl=https://repo.mongodb.org/yum/redhat/7/mongodb-org/4.0/x86_64/
  gpgcheck=1
  enabled=1
  gpgkey=https://www.mongodb.org/static/pgp/server-4.0.asc
  EOT"
  
  # 安装crudini命令行工具
  [root@StackStorm ~]# yum install crudini -y
  
  # 安装MongoDB 
  [root@StackStorm ~]# yum install mongodb-org -y
  
  [root@StackStorm ~]# curl -sL https://packagecloud.io/install/repositories/rabbitmq/erlang/script.rpm.sh | sudo bash
  [root@StackStorm ~]# curl -sL https://packagecloud.io/install/repositories/rabbitmq/rabbitmq-server/script.rpm.sh | sudo bash
  
  [root@StackStorm ~]# yum -y install erlang
  [root@StackStorm ~]# yum -y install rabbitmq-server
  [root@StackStorm ~]# yum -y install redis
  [root@StackStorm ~]# systemctl enable mongod rabbitmq-server redis --now

2.1.3.2 验证 python3-devel

• CentOS/RHEL 7.x 上默认的 python 是 python 2，StackStorm 使用 python3，需要 python3-devel 包。如果 st2 包在已启用的仓库中可用，则安装 st2 包将自动安装 python3-devel。在 CentOS 发行版上，相关的仓库通常是启用的

[root@StackStorm ~]# yum info python3-devel
Loaded plugins: fastestmirror
Loading mirror speeds from cached hostfile
 * base: mirrors.aliyun.com
 * epel: mirrors.aliyun.com
 * extras: mirrors.aliyun.com
 * updates: mirrors.aliyun.com
Available Packages
Name        : python3-devel
Arch        : i686
Version     : 3.6.8
Release     : 21.el7_9
Size        : 217 k
Repo        : updates/7/x86_64
Summary     : Libraries and header files needed for Python development
URL         : https://www.python.org/
License     : Python

2.1.4 设置存储库

• 检测您的平台和体系结构，并设置适当的 StackStorm 存储 库。它还将添加用于包签名的 GPG 密钥。

[root@StackStorm ~]# curl -s https://packagecloud.io/install/repositories/StackStorm/stable/script.rpm.sh | sudo bash

2.1.5 安装 StackStorm 组件

[root@StackStorm ~]# yum install -y st2

• RabbitMQ 连接位于/etc/st2/st2.conf

• MongoDB 位于/etc/st2/st2.conf

• Redis 在协调部分的连接/etc/st2/st2.conf

2.1.6 设置数据存储加密

• 键值存储允许用户存储加密值（机密）。这些是 使用对称加密 （AES256） 存储。

[root@StackStorm ~]# DATASTORE_ENCRYPTION_KEYS_DIRECTORY="/etc/st2/keys"
[root@StackStorm ~]# DATASTORE_ENCRYPTION_KEY_PATH="${DATASTORE_ENCRYPTION_KEYS_DIRECTORY}/datastore_key.json"

[root@StackStorm ~]# mkdir -p ${DATASTORE_ENCRYPTION_KEYS_DIRECTORY}
[root@StackStorm ~]# st2-generate-symmetric-crypto-key --key-path ${DATASTORE_ENCRYPTION_KEY_PATH}

[root@StackStorm ~]# chgrp st2 ${DATASTORE_ENCRYPTION_KEYS_DIRECTORY}
[root@StackStorm ~]# chmod o-r ${DATASTORE_ENCRYPTION_KEYS_DIRECTORY}
[root@StackStorm ~]# chgrp st2 ${DATASTORE_ENCRYPTION_KEY_PATH}
[root@StackStorm ~]# chmod o-r ${DATASTORE_ENCRYPTION_KEY_PATH}

[root@StackStorm ~]# crudini --set /etc/st2/st2.conf keyvalue encryption_key_path ${DATASTORE_ENCRYPTION_KEY_PATH}

[root@StackStorm ~]# st2ctl restart-component st2api

2.1.7 配置 SSH 和 SUDO3

• 为了运行本地和远程 shell 操作，StackStorm 使用特殊的系统用户（默认情况下）。 对于远程 Linux 操作，使用 SSH。我们建议在所有设备上配置基于公钥的 SSH 访问 远程主机。我们还建议配置对 localhost 的 SSH 访问以运行示例和 测试。stanley

  • 创建 StackStorm 系统用户，启用无密码 sudo，并设置对“localhost”的 ssh 访问，以便 基于 SSH 的操作可以在本地进行测试。您需要提升的权限才能执行此操作：

  # Create an SSH system user (default `stanley` user may already exist)
  [root@StackStorm ~]# sudo useradd stanley
  [root@StackStorm ~]# sudo mkdir -p /home/stanley/.ssh
  [root@StackStorm ~]# sudo chmod 0700 /home/stanley/.ssh
  
  # Generate ssh keys
  [root@StackStorm ~]# sudo ssh-keygen -f /home/stanley/.ssh/stanley_rsa -P ""
  
  # Authorize key-based access
  [root@StackStorm ~]# sudo sh -c 'cat /home/stanley/.ssh/stanley_rsa.pub >> /home/stanley/.ssh/authorized_keys'
  [root@StackStorm ~]# sudo chown -R stanley:stanley /home/stanley/.ssh
  
  # Enable passwordless sudo
  [root@StackStorm ~]# sudo sh -c 'echo "stanley    ALL=(ALL)       NOPASSWD: SETENV: ALL" >> /etc/sudoers.d/st2'
  [root@StackStorm ~]# sudo chmod 0440 /etc/sudoers.d/st2
  
  # Make sure `Defaults requiretty` is disabled in `/etc/sudoers`
  [root@StackStorm ~]# sudo sed -i -r "s/^Defaults\s+\+?requiretty/# Defaults +requiretty/g" /etc/sudoers

2.1.8 启动服务

[root@StackStorm ~]# st2ctl start

# 注册传感器、规则和操作
[root@StackStorm ~]# st2ctl reload

2.1.9 验证

• 查看版本

[root@StackStorm ~]# st2 --version
st2 3.8.1, on Python 3.6.8

• 输出 RFC 2822 格式的日期和时间。

[root@StackStorm ~]# st2 run core.local -- date -R
.
id: 66a64cdd02a8613577722802
action.ref: core.local
context.user: stanley
parameters: 
  cmd: date -R
status: succeeded
start_timestamp: Sun, 28 Jul 2024 13:51:25 UTC
end_timestamp: Sun, 28 Jul 2024 13:51:27 UTC
result: 
  failed: false
  return_code: 0
  stderr: ''
  stdout: Sun, 28 Jul 2024 09:51:27 -0400
  succeeded: true

• 列出了操作的执行状态、执行时间和其他相关信息

[root@StackStorm ~]# st2 run core.remote hosts='localhost' -- uname -a
.
id: 66a64d0702a8613577722805
action.ref: core.remote
context.user: stanley
parameters: 
  cmd: uname -a
  hosts: localhost
status: succeeded
start_timestamp: Sun, 28 Jul 2024 13:52:07 UTC
end_timestamp: Sun, 28 Jul 2024 13:52:09 UTC
result: 
  localhost:
    failed: false
    return_code: 0
    stderr: ''
    stdout: 'Linux StackStorm 3.10.0-1160.71.1.el7.x86_64 #1 SMP Tue Jun 28 15:37:28 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux'
    succeeded: true

• 安装软件包

[root@StackStorm ~]# st2 pack install st2
​
For the "st2" pack, the following content will be registered:
​
actions   |  24
rules     |  0
sensors   |  0
aliases   |  12
triggers  |  0
​
Installation may take a while for packs with many items.
​
        [ succeeded ] init_task
        [ succeeded ] download_pack
        [ succeeded ] make_a_prerun
        [ succeeded ] get_pack_dependencies
        [ succeeded ] check_dependency_and_conflict_list
        [ succeeded ] install_pack_requirements
        [ succeeded ] get_pack_warnings
        [ succeeded ] register_pack
​
+-------------+----------------------------------------+
| Property    | Value                                  |
+-------------+----------------------------------------+
| ref         | st2                                    |
| name        | st2                                    |
| description | StackStorm utility actions and aliases |
| version     | 2.0.1                                  |
| author      | StackStorm, Inc.                       |
+-------------+----------------------------------------+

• st2命令帮助

[root@StackStorm ~]# st2 -h

参数/选项	说明
-h, --help	显示帮助信息并退出
--version	显示程序的版本号并退出
--url BASE_URL	API服务器的基础URL。假设所有服务器使用相同的基础URL，默认端口。默认从环境变量获取ST2_BASE_URL。
--auth-url AUTH_URL	认证服务的URL。默认从环境变量获取ST2_AUTH_URL。
--api-url API_URL	API服务器的URL。默认从环境变量获取ST2_API_URL。
--stream-url STREAM_URL	流端点的URL。默认从环境变量获取ST2_STREAM_URL。
--api-version API_VERSION	要使用的API版本。默认从环境变量获取ST2_API_VERSION。
--cacert CACERT	SSL端点的CA证书捆绑路径。默认从环境变量获取ST2_CACERT。如果不提供，则不验证SSL证书。
--basic-auth BASIC_AUTH	用于认证的可选附加基本认证凭据。
--config-file CONFIG_FILE	CLI配置文件的路径。
--print-config	解析配置文件并打印值。
--skip-config	不解析和使用CLI配置文件。
--debug	启用调试模式。

命令	说明
run	手动调用一个操作。
action	作为对外部事件响应而发生的活动。
action-alias	操作别名。
auth	认证用户并获取访问令牌。
login	认证用户，获取访问令牌，并更新CLI配置目录。
whoami	显示当前认证的用户。
apikey	API密钥。
execution	一个操作的调用。
inquiry	Inquiry提供在工作流中提问并等待响应的机会。
key	键值对用于存储常用配置，以便在传感器、操作和规则中重复使用。
pack	一组相关的集成资源：操作、规则和传感器。
policy	强制执行的策略。
policy-type	可以应用于资源的策略类型。
rule	基于某些标准选择性地在“触发器”上调用“操作”的规范。
webhook	Webhooks。
timer	定时器。
runner	运行器是特定类别操作的处理程序。
sensor	允许将StackStorm与外部系统集成的适配器。
trace	相关的执行、规则和触发实例的一组。
trigger	映射到st2输入的外部事件。它是st2的调用点。
trigger-instance	st2接收到的实际触发器实例。
rule-enforcement	表示规则强制执行的模型。
workflow	工作流编写相关操作的命令。仅支持orquesta工作流。
service-registry	服务注册组和成员相关的命令。
role	RBAC角色。
role-assignment	RBAC角色分配。

2.1.10 配置身份验证

• 于文件的提供程序设置身份验证

# 使用密码创建用户
[root@StackStorm ~]# yum -y install httpd-tools
​
# 创建密码文件
[root@StackStorm ~]# echo 'Ch@ngeMe' | sudo htpasswd -i /etc/st2/htpasswd st2admin

• 在以下位置启用和配置身份验证：/etc/st2/st2.conf

• 重新启动 st2api 服务

[root@StackStorm ~]# st2ctl restart-component st2api

• 进行身份验证，并检查其是否正常工作

[root@StackStorm ~]# st2 login st2admin
Password: Ch@ngeMe
Logged in as st2admin
​
Note: You didn't use --write-password option so the password hasn't been stored in the client config and you will need to login again in 24 hours when the auth token expires.
As an alternative, you can run st2 login command with the "--write-password" flag, but keep it mind this will cause it to store the password in plain-text in the client config file (~/.st2/config).
[root@StackStorm ~]# st2 action list
+---------------------------------+---------+------------------------------------+
| ref                             | pack    | description                        |
+---------------------------------+---------+------------------------------------+
| chatops.format_execution_result | chatops | Format an execution result for     |
|                                 |         | chatops                            |
| chatops.match                   | chatops | Match a string to an action alias  |
| chatops.match_and_execute       | chatops | Execute a chatops string to an     |
|                                 |         | action alias                       |
| chatops.post_message            | chatops | Post a message to stream for       |
|                                 |         | chatops                            |
| chatops.post_result             | chatops | Post an execution result to stream |
|                                 |         | for chatops                        |
| chatops.run                     | chatops | Match a text chatops command,      |
|                                 |         | execute it and post the result     |
| core.announcement               | core    | Action that broadcasts the         |
|                                 |         | announcement to all stream         |
|                                 |         | consumers.                         |
| core.ask                        | core    | Action for initiating an Inquiry   |
|                                 |         | (usually in a workflow)            |
| core.echo                       | core    | Action that executes the Linux     |
|                                 |         | echo command on the localhost.     |
| core.error                      | core    | Action that executes the Linux     |
|                                 |         | echo command (to stderr) on the    |
|                                 |         | localhost.                         |
| core.http                       | core    | Action that performs an http       |
|                                 |         | request.                           |
| core.inject_trigger             | core    | Action which injects a new trigger |
|                                 |         | in the system.                     |
| core.local                      | core    | Action that executes an arbitrary  |
|                                 |         | Linux command on the localhost.    |
| core.local_sudo                 | core    | Action that executes an arbitrary  |
|                                 |         | Linux command on the localhost.    |
| core.noop                       | core    | Action that does nothing           |
| core.pause                      | core    | Action to pause current thread of  |
|                                 |         | workflow/sub-workflow.             |
| core.remote                     | core    | Action to execute arbitrary linux  |
|                                 |         | command remotely.                  |
| core.remote_sudo                | core    | Action to execute arbitrary linux  |
|                                 |         | command remotely.                  |
| core.sendmail                   | core    | This sends an email                |
| core.uuid                       | core    | Generate a new UUID (default       |
|                                 |         | uuid4)                             |
| core.winrm_cmd                  | core    | Action to execute arbitrary        |
|                                 |         | Windows Command Prompt command     |
|                                 |         | remotely via WinRM.                |
| core.winrm_ps_cmd               | core    | Action to execute arbitrary        |
|                                 |         | Windows PowerShell command         |
|                                 |         | remotely via WinRM.                |
| linux.check_loadavg             | linux   | Check CPU Load Average on a Host   |
| linux.check_processes           | linux   | Check Interesting Processes        |
| linux.cp                        | linux   | Copy file(s)                       |
| linux.diag_loadavg              | linux   | Diagnostic workflow for high load  |
|                                 |         | alert                              |
| linux.dig                       | linux   | Dig action                         |
| linux.file_touch                | linux   | Touches a file                     |
| linux.lsof                      | linux   | Run lsof                           |
| linux.lsof_pids                 | linux   | Run lsof for a group of PIDs       |
| linux.mv                        | linux   | Move file(s)                       |
| linux.netstat                   | linux   | Run netstat                        |
| linux.netstat_grep              | linux   | Grep netstat results               |
| linux.pkill                     | linux   | Kill processes using pkill         |
| linux.rm                        | linux   | Remove file(s)                     |
| linux.rsync                     | linux   | Copy file(s) from one place to     |
|                                 |         | another w/ rsync                   |
| linux.scp                       | linux   | Secure copy file(s)                |
| linux.service                   | linux   | Stops, Starts, or Restarts a       |
|                                 |         | service                            |
| linux.traceroute                | linux   | Traceroute a Host                  |
| linux.vmstat                    | linux   | Run vmstat                         |
| linux.wait_for_ssh              | linux   | Action which waits for a SSH       |
|                                 |         | server to become accessible. By    |
|                                 |         | default, if no credentials are     |
|                                 |         | provided, this action will try to  |
|                                 |         | authenticate using the system user |
|                                 |         | username and key file.             |
| packs.delete                    | packs   | Deletes the pack from local        |
|                                 |         | content repository.                |
| packs.download                  | packs   | Downloads packs and places it in   |
|                                 |         | the local content repository.      |
| packs.get                       | packs   | Get information about installed    |
|                                 |         | pack.                              |
| packs.get_config                | packs   | Returns config variables           |
| packs.get_pack_dependencies     | packs   | Get pack dependencies specified in |
|                                 |         | pack.yaml                          |
| packs.get_pack_warnings         | packs   | Get pack warnings from analysing   |
|                                 |         | pack.yaml                          |
| packs.install                   | packs   | Installs or upgrades a pack into   |
|                                 |         | local content repository, either   |
|                                 |         | by git URL or a short name         |
|                                 |         | matching an index entry. Will      |
|                                 |         | download pack, load the actions,   |
|                                 |         | sensors and rules from the pack.   |
|                                 |         | Note that install requires reboot  |
|                                 |         | of some st2 services.              |
| packs.load                      | packs   | Action that reloads all st2        |
|                                 |         | content.                           |
| packs.restart_component         | packs   | Action that restarts st2 service.  |
| packs.search                    | packs   | Search the index for a pack with   |
|                                 |         | any attribute matching the query.  |
| packs.setup_virtualenv          | packs   | Set up virtual environment for the |
|                                 |         | provided packs                     |
| packs.show                      | packs   | Get detailed information about     |
|                                 |         | pack from the remote StackStorm    |
|                                 |         | exchange index.                    |
| packs.uninstall                 | packs   | Uninstalls packs from local        |
|                                 |         | content repository. Removes pack   |
|                                 |         | and content from st2. Note that    |
|                                 |         | uninstall require reboot of some   |
|                                 |         | st2 services.                      |
| packs.unload                    | packs   | Unregisters all content from a     |
|                                 |         | pack.                              |
| packs.update_virtualenv         | packs   | Update / reinstall Python          |
|                                 |         | dependencies listed in             |
|                                 |         | requirements.txt inside the pack   |
|                                 |         | virtual environment                |
| packs.virtualenv_prerun         | packs   | Transformation step to conver      |
|                                 |         | packs_status to list of packs.     |
| st2.actions.list                | st2     | Retrieve a list of available       |
|                                 |         | StackStorm actions.                |
| st2.call_home                   | st2     | Sends anonymous data install data  |
|                                 |         | to a StackStorm write-only S3      |
|                                 |         | dropbox                            |
| st2.check_permissions_anon_data | st2     | Check if sending anonymous data is |
|                                 |         | allowed.                           |
| st2.executions.cancel           | st2     | Cancel action executions.          |
| st2.executions.create           | st2     | Create an action execution.        |
| st2.executions.get              | st2     | Retrieve details of a single       |
|                                 |         | execution.                         |
| st2.executions.get_root         | st2     | Traverse to the root execution of  |
|                                 |         | given ID and retrieve its details. |
| st2.executions.list             | st2     | Retrieve a list of executions.     |
| st2.executions.pause            | st2     | Pause action executions (workflow  |
|                                 |         | executions only).                  |
| st2.executions.re_run           | st2     | Re-run an action execution.        |
| st2.executions.resume           | st2     | Resume action executions (workflow |
|                                 |         | executions only).                  |
| st2.inquiry.respond             | st2     | Respond to an inquiry              |
| st2.kv.delete                   | st2     | Delete value from datastore        |
| st2.kv.get                      | st2     | Get value from datastore           |
| st2.kv.get_object               | st2     | Deserialize and retrieve JSON      |
|                                 |         | serialized object from a datastore |
| st2.kv.grep                     | st2     | Grep for keys in datastore         |
| st2.kv.grep_object              | st2     | Grep for keys in datastore and     |
|                                 |         | deserialize JSON serialized        |
|                                 |         | values. This will perform JSON     |
|                                 |         | serialization on all values that   |
|                                 |         | match the query.                   |
| st2.kv.set                      | st2     | Set value in datastore             |
| st2.kv.set_object               | st2     | Serialize and store object in a    |
|                                 |         | datastore                          |
| st2.rules.disable               | st2     | Disable an existing rule           |
| st2.rules.enable                | st2     | Enable an existing rule            |
| st2.rules.list                  | st2     | Retrieve a list of available       |
|                                 |         | StackStorm rules                   |
| st2.sensors.list                | st2     | Retrieve a list of available       |
|                                 |         | StackStorm sensors.                |
| st2.upload_to_s3                | st2     | Sends collected data to write-only |
|                                 |         | StackStorm S3 bucket               |
+---------------------------------+---------+------------------------------------+

2.1.11 安装 Webul 并设置 SSL 终止

• NGINX用于提供 WebUI 静态文件，将 HTTP 重定向到 HTTPS，提供 SSL 终止，以及反向代理 st2auth 和 st2api API 端点。要设置它：安装 and 包，生成证书或将您现有的证书放在 下，并使用 StackStorm 提供的站点配置文件 st2.conf配置 nginx。

• StackStorm 依赖于 Nginx 版本 >=1.7.5。

[root@StackStorm ~]# rpm --import http://nginx.org/keys/nginx_signing.key
[root@StackStorm ~]# bash -c "cat <<EOT > /etc/yum.repos.d/nginx.repo
[nginx]
name=nginx repo
baseurl=http://nginx.org/packages/rhel/\\\$releasever/x86_64/
gpgcheck=1
enabled=1
EOT"
​
[root@StackStorm ~]# sed -i 's/^\(enabled=1\)$/exclude=nginx\n\1/g' /etc/yum.repos.d/epel.repo
[root@StackStorm ~]# yum install nginx -y
[root@StackStorm ~]# yum install st2web -y

• 创建SSL证书

[root@StackStorm ~]# mkdir -p /etc/ssl/st2
[root@StackStorm ~]# openssl req -x509 -newkey rsa:2048 -keyout /etc/ssl/st2/st2.key -out /etc/ssl/st2/st2.crt -days 365 -nodes -subj "/C=US/ST=California/L=Palo Alto/O=StackStorm/OU=Information Technology/CN=$(hostname)"
Generating a 2048 bit RSA private key
......................................+++
...........................................................+++
writing new private key to '/etc/ssl/st2/st2.key'
-----
[root@StackStorm ~]# cp /usr/share/doc/st2/conf/nginx/st2.conf /etc/nginx/conf.d/ 
[root@StackStorm ~]# sed -i 's/default_server//g' /etc/nginx/nginx.conf

• 启动服务

[root@StackStorm ~]# systemctl enable nginx.service --now

• 设置防火墙规则

[root@StackStorm ~]# firewall-cmd --zone=public --add-service=http --add-service=https
[root@StackStorm ~]# firewall-cmd --zone=public --permanent --add-service=http --add-service=https
[root@StackStorm ~]# firewall-cmd --reload

2.1.12 访问Web UI

访问：https://IP

• 用户名st2admin,密码 Ch@ngeMe

# 修改密码方法
[root@StackStorm ~]# st2ctl reload --register-all
[root@StackStorm ~]# htpasswd /etc/st2/htpasswd st2admin    # 改密码
New password: 
Re-type new password: 
Adding password for user st2admin

2.1.13 设置 Chatops

• 如果已经运行了一个 Hubot 实例，你可以安装 hubot-stackstorm 插件并配置 StackStorm 环境变量，如 描述如下。否则，启用 StackStorm ChatOps的最简单方法是使用 st2chatops 包。

• 验证是否已安装包，并已启用通知规则：chatops

[root@StackStorm ~]# ll /opt/stackstorm/packs/chatops
total 20
drwxrwxr-x 4 root st2packs  280 Jul 28 09:34 actions
-rwxrwxr-x 1 root st2packs   38 Nov 29  2023 BUILD
-rwxrwxr-x 1 root st2packs  587 Nov 29  2023 CHANGES.md
-rwxrwxr-x 1 root st2packs 2434 Nov 29  2023 icon.png
-rwxrwxr-x 1 root st2packs  242 Nov 29  2023 pack.yaml
-rwxrwxr-x 1 root st2packs  472 Nov 29  2023 README.md
drwxrwxr-x 2 root st2packs   57 Jul 28 09:34 rules
drwxrwxr-x 3 root st2packs   83 Jul 28 09:34 tests

• 添加 NodeJS v14 仓库

[root@StackStorm ~]# curl -sL https://rpm.nodesource.com/setup_14.x | sudo -E bash -

• 安装包：st2chatops

  • 查看并编辑配置文件以将其指向 您的 StackStorm 安装和您正在使用的聊天服务。至少，您应该生成一个 API 密钥并设置变量。默认情况下，它们应位于同一主机上。如果不是这种情况，请 更新 and 变量，或者仅使用 指向正确的主机。/opt/stackstorm/chatops/st2chatops.env``ST2_API_KEY``st2api``st2auth``ST2_API``ST2_AUTH_URL``ST2_HOSTNAME

    • 示例配置使用 Slack。要进行此设置，请转到 Slack Web 管理员界面，创建 一个 Bot，并将身份验证令牌复制到 .HUBOT_SLACK_TOKEN

    • 如果您正在使用不同的聊天服务，请在以下部分下设置相应的环境变量：Slack、Flowdock、IRC、Mattermost、RocketChat、XMPP。Chat service adapter settings``st2chatops.env

[root@StackStorm ~]# yum install st2chatops -y

• 启动服务

[root@StackStorm ~]# systemctl enable --now st2chatops

• 重新加载 st2 包以确保规则已注册

[root@StackStorm ~]# st2ctl reload --register-all

3. StackStorm基本用法

3.1 基本命令

• 查看st2版本

[root@StackStorm ~]# st2 --version
st2 3.8.1, on Python 3.6.8

• 列出某个名为 "core" 的包中的所有动作

[root@StackStorm ~]# st2 action list --pack=core
+---------------------+------+---------------------------------------------+
| ref                 | pack | description                                 |
+---------------------+------+---------------------------------------------+
| core.announcement   | core | Action that broadcasts the announcement to  |
|                     |      | all stream consumers.                       |
| core.ask            | core | Action for initiating an Inquiry (usually   |
|                     |      | in a workflow)                              |
| core.echo           | core | Action that executes the Linux echo command |
|                     |      | on the localhost.                           |
| core.error          | core | Action that executes the Linux echo command |
|                     |      | (to stderr) on the localhost.               |
| core.http           | core | Action that performs an http request.       |
| core.inject_trigger | core | Action which injects a new trigger in the   |
|                     |      | system.                                     |
| core.local          | core | Action that executes an arbitrary Linux     |
|                     |      | command on the localhost.                   |
| core.local_sudo     | core | Action that executes an arbitrary Linux     |
|                     |      | command on the localhost.                   |
| core.noop           | core | Action that does nothing                    |
| core.pause          | core | Action to pause current thread of           |
|                     |      | workflow/sub-workflow.                      |
| core.remote         | core | Action to execute arbitrary linux command   |
|                     |      | remotely.                                   |
| core.remote_sudo    | core | Action to execute arbitrary linux command   |
|                     |      | remotely.                                   |
| core.sendmail       | core | This sends an email                         |
| core.uuid           | core | Generate a new UUID (default uuid4)         |
| core.winrm_cmd      | core | Action to execute arbitrary Windows Command |
|                     |      | Prompt command remotely via WinRM.          |
| core.winrm_ps_cmd   | core | Action to execute arbitrary Windows         |
|                     |      | PowerShell command remotely via WinRM.      |
+---------------------+------+---------------------------------------------+

• 列出触发器

[root@StackStorm ~]# st2 trigger list
+--------------------------------------+-------+---------------------------------------------+
| ref                                  | pack  | description                                 |
+--------------------------------------+-------+---------------------------------------------+
| core.st2.CronTimer                   | core  | Triggers whenever current time matches the  |
|                                      |       | specified time constaints like a UNIX cron  |
|                                      |       | scheduler.                                  |
| core.st2.DateTimer                   | core  | Triggers exactly once when the current time |
|                                      |       | matches the specified time. e.g.            |
|                                      |       | timezone:UTC date:2014-12-31 23:59:59.      |
| core.st2.IntervalTimer               | core  | Triggers on specified intervals. e.g. every |
|                                      |       | 30s, 1week etc.                             |
| core.st2.action.file_written         | core  | Trigger encapsulating action file being     |
|                                      |       | written on disk.                            |
| core.st2.generic.actiontrigger       | core  | Trigger encapsulating the completion of an  |
|                                      |       | action execution.                           |
| core.st2.generic.inquiry             | core  | Trigger indicating a new "inquiry" has      |
|                                      |       | entered "pending" status                    |
| core.st2.generic.notifytrigger       | core  | Notification trigger.                       |
| core.st2.key_value_pair.create       | core  | Trigger encapsulating datastore item        |
|                                      |       | creation.                                   |
| core.st2.key_value_pair.delete       | core  | Trigger encapsulating datastore item        |
|                                      |       | deletion.                                   |
| core.st2.key_value_pair.update       | core  | Trigger encapsulating datastore set action. |
| core.st2.key_value_pair.value_change | core  | Trigger encapsulating a change of datastore |
|                                      |       | item value.                                 |
| core.st2.sensor.process_exit         | core  | Trigger indicating sensor process is        |
|                                      |       | stopped.                                    |
| core.st2.sensor.process_spawn        | core  | Trigger indicating sensor process is        |
|                                      |       | started up.                                 |
| core.st2.webhook                     | core  | Trigger type for registering webhooks that  |
|                                      |       | can consume arbitrary payload.              |
| linux.file_watch.line                | linux | Trigger which indicates a new line has been |
|                                      |       | detected                                    |
+--------------------------------------+-------+---------------------------------------------+
​

• 列出规则

[root@StackStorm ~]# st2 rule list
+-----------------------+---------+----------------------------------+---------+
| ref                   | pack    | description                      | enabled |
+-----------------------+---------+----------------------------------+---------+
| chatops.notify        | chatops | Notification rule to send        | True    |
|                       |         | results of action executions to  |         |
|                       |         | stream for chatops               |         |
| chatops.notify-errbot | chatops | Notification rule to send        | True    |
|                       |         | results of action executions to  |         |
|                       |         | stream for errbot.               |         |
+-----------------------+---------+----------------------------------+---------+

• 触发动作

[root@StackStorm ~]# st2 run core.local -- date -R
.
id: 66a84d08b03debb9dc1820d5
action.ref: core.local
context.user: stanley
parameters: 
  cmd: date -R
status: succeeded
start_timestamp: Tue, 30 Jul 2024 02:16:40 UTC
end_timestamp: Tue, 30 Jul 2024 02:16:41 UTC
result: 
  failed: false
  return_code: 0
  stderr: ''
  stdout: Mon, 29 Jul 2024 22:16:41 -0400
  succeeded: true
 
- core.local 指定了动作的来源，这里是 core 包中的 local 动作。
- -- 是一个参数分隔符，它告诉 st2 命令行工具后面的内容是传递给动作的参数。
- date -R 是传递给 core.local 动作的参数，这里 date -R 是一个 shell 命令，用于输出 ISO 8601 格式   的日期和时间。

• 列出所有执行的动作

[root@StackStorm ~]# st2 execution list
+--------------------------+---------------+--------------+------------------------+-------------------+---------------+
| id                       | action.ref    | context.user | status                 | start_timestamp   | end_timestamp |
+--------------------------+---------------+--------------+------------------------+-------------------+---------------+
| 66a84989a6fbe3861f9f57cf | core.local    | stanley      | succeeded (1s elapsed) | Tue, 30 Jul 2024  | Tue, 30 Jul   |
|                          |               |              |                        | 02:01:45 UTC      | 2024 02:01:46 |
|                          |               |              |                        |                   | UTC           |
| 66a84995a6fbe3861f9f57d2 | core.remote   | stanley      | succeeded (1s elapsed) | Tue, 30 Jul 2024  | Tue, 30 Jul   |
|                          |               |              |                        | 02:01:57 UTC      | 2024 02:01:58 |
|                          |               |              |                        |                   | UTC           |
| 66a849a7a6fbe3861f9f57d5 | packs.install | stanley      | failed (29s elapsed)   | Tue, 30 Jul 2024  | Tue, 30 Jul   |
|                          |               |              |                        | 02:02:15 UTC      | 2024 02:02:44 |
|                          |               |              |                        |                   | UTC           |
| 66a84d08b03debb9dc1820d5 | core.local    | stanley      | succeeded (1s elapsed) | Tue, 30 Jul 2024  | Tue, 30 Jul   |
|                          |               |              |                        | 02:16:40 UTC      | 2024 02:16:41 |
|                          |               |              |                        |                   | UTC           |
+--------------------------+---------------+--------------+------------------------+-------------------+---------------+
[root@StackStorm ~]# 

[root@StackStorm ~]# st2 run core.remote hosts='localhost' -- uname -a
.
id: 66a84d64b03debb9dc1820d8
action.ref: core.remote
context.user: stanley
parameters: 
  cmd: uname -a
  hosts: localhost
status: succeeded
start_timestamp: Tue, 30 Jul 2024 02:18:12 UTC
end_timestamp: Tue, 30 Jul 2024 02:18:13 UTC
result: 
  localhost:
    failed: false
    return_code: 0
    stderr: ''
    stdout: 'Linux StackStorm 3.10.0-1160.71.1.el7.x86_64 #1 SMP Tue Jun 28 15:37:28 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux'
    succeeded: true

• core.remote 指的是 core 包中的 remote 动作，它通常用于在远程主机上执行命令。

• hosts='localhost' 是传递给 remote 动作的参数，指定了目标主机的列表。在这个例子中，localhost 表示命令将在执行该命令的同一台机器上执行。

• -- uname -a 是传递给 remote 动作的命令，uname -a 是一个在 Unix-like 系统上用来打印系统信息的命令。

3.2 规则

3.2.1 定义规则

• 当事件发生时，StackStorm 使用规则来运行操作或工作流。通常监视事件 通过传感器。当传感器捕获到事件时，它会触发触发器。触发跳闸规则，规则 检查条件，如果匹配，它将运行一个操作。

• 规则定义是一个 YAML 文件，包含三个部分：触发器、条件和操作。这 示例设置为对 Webhook 触发器做出反应，并将过滤条件应用于 触发器。

• 此示例中的 webhook 设置为侦听位于 的子 url。当对此 URL 进行 POST 时，触发器 火灾。如果条件匹配（在本例中，payload 中的值为 ），则有效负载将为 附加到 StackStorm 系统用户的主目录中的文件。默认情况下，这是 ，因此文件将位于 。sample``https://{host}/api/v1/webhooks/sample``st2``st2.webhook_sample.out``stanley``/home/stanley/st2.webhook_sample.out

[root@StackStorm ~]# cat /usr/share/doc/st2/examples/rules/sample_rule_with_webhook.yaml
---
    name: "sample_rule_with_webhook"
    pack: "examples"
    description: "Sample rule dumping webhook payload to a file."
    enabled: true
​
    trigger:
        type: "core.st2.webhook"
        parameters:
            url: "sample"
​
    criteria:
        trigger.body.name:
            pattern: "st2"
            type: "equals"
​
    action:
        ref: "core.local"
        parameters:
            cmd: "echo \"{{trigger.body}}\" >> ~/st2.webhook_sample.out ; sync"

StackStorm 规则（rule）的定义，用于自动化处理通过 webhook 触发的事件。下面是对每个部分的详细解释：

• 名称和包:

• name: "sample_rule_with_webhook"：定义了规则的名称，这里是 sample_rule_with_webhook。

• pack: "examples"：指定了规则所属的包，这里是 examples 包。

• 描述:

• description: "Sample rule dumping webhook payload to a file."：提供了规则的描述，说明这个规则是将 webhook 负载转储到文件中。

• 启用状态:

• enabled: true：表明这个规则是启用的，也就是说它将被执行。

• 触发器（Trigger）:

• type: "core.st2.webhook"：指定触发器类型为 core.st2.webhook，这意味着规则将通过 webhook 触发。

• parameters：

  • url: "sample"：定义了 webhook 的 URL，这里设置为 sample。这意味着当有请求发送到这个 URL 时，规则会被触发。

• 条件（Criteria）:

• trigger.body.name：

  • pattern: "st2"：指定了一个模式，匹配 webhook 负载中的 name 字段。

  • type: "equals"：指定了匹配类型为 equals，即只有当 name 字段的值等于 st2 时，才会满足条件。

• 动作（Action）:

• ref: "core.local"：指定了要执行的动作是 core.local，这是一个在本地执行命令的动作。

• parameters：

  • cmd: "echo \"{{trigger.body}}\" >> ~/st2.webhook_sample.out ; sync"：定义了要执行的命令。这里使用了 {{trigger.body}} 模板变量，它会被替换为 webhook 触发时的负载内容。命令的作用是将 webhook 负载的内容追加到用户主目录下的 st2.webhook_sample.out 文件中，并执行 sync 命令确保数据写入磁盘。

3.2.3 部署规则

• StackStorm 可以配置为自动加载规则，也可以使用 API 或 CLI 部署规则：

# 创建规则
[root@StackStorm ~]# st2 rule create /usr/share/doc/st2/examples/rules/sample_rule_with_webhook.yaml
+---------------+--------------------------------------------------------------+
| Property      | Value                                                        |
+---------------+--------------------------------------------------------------+
| id            | 66a84f46b03debb9dc1820db                                     |
| name          | sample_rule_with_webhook                                     |
| pack          | examples                                                     |
| description   | Sample rule dumping webhook payload to a file.               |
| action        | {                                                            |
|               |     "ref": "core.local",                                     |
|               |     "parameters": {                                          |
|               |         "cmd": "echo "{{trigger.body}}" >>                   |
|               | ~/st2.webhook_sample.out ; sync"                             |
|               |     }                                                        |
|               | }                                                            |
| context       | {                                                            |
|               |     "user": "stanley"                                        |
|               | }                                                            |
| criteria      | {                                                            |
|               |     "trigger.body.name": {                                   |
|               |         "pattern": "st2",                                    |
|               |         "type": "equals"                                     |
|               |     }                                                        |
|               | }                                                            |
| enabled       | True                                                         |
| metadata_file |                                                              |
| ref           | examples.sample_rule_with_webhook                            |
| tags          |                                                              |
| trigger       | {                                                            |
|               |     "type": "core.st2.webhook",                              |
|               |     "parameters": {                                          |
|               |         "url": "sample"                                      |
|               |     },                                                       |
|               |     "ref": "core.5ec19a72-2890-4180-92aa-3d6591ecc28f"       |
|               | }                                                            |
| type          | {                                                            |
|               |     "ref": "standard",                                       |
|               |     "parameters": {}                                         |
|               | }                                                            |
| uid           | rule:examples:sample_rule_with_webhook                       |
+---------------+--------------------------------------------------------------+
You have mail in /var/spool/mail/root
​
# 列出该规则
[root@StackStorm ~]# st2 rule list --pack=examples
​
+----------------------------------+----------+----------------------------------+---------+
| ref                              | pack     | description                      | enabled |
+----------------------------------+----------+----------------------------------+---------+
| examples.sample_rule_with_webhoo | examples | Sample rule dumping webhook      | True    |
| k                                |          | payload to a file.               |         |
+----------------------------------+----------+----------------------------------+---------+
​
$ st2 rule get examples.sample_rule_with_webhook # 可获取详细信息

• 创建规则后，webhook 开始监听 。触发 POST，签出 ，并查看它是否将有效负载附加到文件中。

[root@StackStorm ~]# curl -k https://localhost/api/v1/webhooks/sample -d '{"foo": "bar", "name": "st2"}' -H 'Content-Type: application/json' -H 'X-Auth-Token: put_token_here'
{"foo":"bar","name":"st2"}
​
- https://localhost/api/v1/webhooks/sample：这是 webhook 的 URL，表示请求将发送到本地主机（localhost）上的 StackStorm API 的 webhook 端点 sample。
​
# -d '{"foo": "bar", "name": "st2"}'：-d 选项后面跟着的是请求体（data），这里是一段 JSON 格式的数据，包含两个键值对：foo 的值是 bar，name 的值是 st2。
​
# -H 'Content-Type: application/json'：这个 -H 选项指定了请求头（header），告诉服务器请求体是 JSON 格式。
​
# -H 'X-Auth-Token: put_token_here'：这个 -H 选项也是指定请求头，用于传递认证令牌（authentication token）。put_token_here 应该被替换为实际的认证令牌。
​
# {"foo":"bar","name":"st2"}：这是命令执行后返回的响应，显示了发送到 webhook 的原始 JSON 数据。
​
# StackStorm 规则触发的 webhook 是否成功执行，并将结果写入了文件 /home/stanley/st2.webhook_sample.out。
[root@StackStorm ~]# tail /home/stanley/st2.webhook_sample.out
{'foo': 'bar', 'name': 'st2'}

• 执行该动作

# 模拟了一个 HTTP POST 请求到 StackStorm 的 webhook URL。
[root@StackStorm ~]# st2 run core.http method=POST body='{"you": "too", "name": "st2"}' url=https://localhost/api/v1/webhooks/sample headers='x-auth-token=put_token_here,content-type=application/json' verify_ssl_cert=False
.
id: 66a850cab03debb9dc1820dd
action.ref: core.http
context.user: stanley
parameters: 
  body: '{"you": "too", "name": "st2"}'
  headers:
    content-type: application/json
    x-auth-token: put_token_here
  method: POST
  url: https://localhost/api/v1/webhooks/sample
  verify_ssl_cert: false
status: succeeded
start_timestamp: Tue, 30 Jul 2024 02:32:42 UTC
end_timestamp: Tue, 30 Jul 2024 02:32:44 UTC
result: 
  body:
    name: st2
    you: too
  headers:
    Access-Control-Allow-Credentials: 'true'
    Access-Control-Allow-Headers: Content-Type,Authorization,X-Auth-Token,St2-Api-Key,X-Request-ID
    Access-Control-Allow-Methods: GET,POST,PUT,DELETE,OPTIONS
    Access-Control-Allow-Origin: http://127.0.0.1:3000
    Access-Control-Expose-Headers: Content-Type,X-Limit,X-Total-Count,X-Request-ID
    Connection: keep-alive
    Content-Length: '26'
    Content-Type: application/json
    Date: Tue, 30 Jul 2024 02:32:44 GMT
    Server: nginx
    X-Frame-Options: DENY
    X-Request-ID: e717be11-3211-485c-be98-701ebfc107b2
  parsed: true
  status_code: 202
  
# url=https://httpbin.org/basic-auth/st2/pwd：指定了请求的目标 URL，这里是 httpbin 服务的一个基本认证端点，需要用户名和密码才能访问。
# username=st2 和 password=pwd：提供了 HTTP 基本认证所需的用户名和密码。
[root@StackStorm ~]# st2 run core.http url=https://httpbin.org/basic-auth/st2/pwd username=st2 password=pwd
.
id: 66a85129b03debb9dc1820e0
action.ref: core.http
context.user: stanley
parameters: 
  password: '********'
  url: https://httpbin.org/basic-auth/st2/pwd
  username: st2
status: succeeded
start_timestamp: Tue, 30 Jul 2024 02:34:17 UTC
end_timestamp: Tue, 30 Jul 2024 02:34:19 UTC
result: 
  body:
    authenticated: true
    user: st2
  headers:
    Access-Control-Allow-Credentials: 'true'
    Access-Control-Allow-Origin: '*'
    Connection: keep-alive
    Content-Length: '46'
    Content-Type: application/json
    Date: Tue, 30 Jul 2024 02:34:19 GMT
    Server: gunicorn/19.9.0
  parsed: true
  status_code: 200

• 将 StackStorm 的示例包从文档目录复制到 StackStorm 的包目录。

[root@StackStorm ~]# cp -r /usr/share/doc/st2/examples/ /opt/stackstorm/packs/
[root@StackStorm ~]# chown -R root:st2packs /opt/stackstorm/packs/examples
[root@StackStorm ~]# chmod -R g+w /opt/stackstorm/packs/examples
[root@StackStorm ~]# st2ctl reload --register-all

3.2.4 数据存储

在 StackStorm 中，数据存储服务（Datastore Service）是一个用于存储和共享数据的地方，它可以在规则和工作流中被引用。使用数据存储服务可以方便地管理配置信息、敏感数据等，而不需要硬编码在脚本或规则定义中。

以下是如何使用 StackStorm 数据存储服务来存储和引用值的步骤：

• 存储值： 在 StackStorm 的 Web 界面中，你可以访问数据存储服务来添加或修改数据。例如，要创建一个键值对 user=stanley，你可以添加一个新的条目，键（Key）是 user，值（Value）是 stanley。

• 引用值： 在规则或工作流中，你可以通过特定的语法来引用存储在数据存储服务中的值。例如，如果你存储了一个键为 my_parameter 的值，你可以在动作的参数或工作流的任务中使用以下语法来引用它：

  {{st2kv.system.my_parameter}}

  这将被替换为数据存储服务中 my_parameter 键对应的值。

• 使用数据存储值： 当你在规则或工作流中使用上述语法时，StackStorm 会自动从数据存储服务中检索相应的值，并将其插入到动作的执行上下文中。

[root@StackStorm ~]# st2 key set user stanley
+------------------+--------------+
| Property         | Value        |
+------------------+--------------+
| name             | user         |
| value            | stanley      |
| scope            | st2kv.system |
| expire_timestamp |              |
+------------------+--------------+
[root@StackStorm ~]# st2 key list
+------+---------+--------+-----------+--------------+------+------------------+
| name | value   | secret | encrypted | scope        | user | expire_timestamp |
+------+---------+--------+-----------+--------------+------+------------------+
| user | stanley | False  | False     | st2kv.system |      |                  |
+------+---------+--------+-----------+--------------+------+------------------+

3.3 动作

在 StackStorm 中，规则和工作流是自动化操作的核心组件。以下是几个概念的解释：

• 触发规则：在 StackStorm 中，规则定义了在特定条件满足时触发的动作。这些条件可以是时间（例如，定时任务）、事件（例如，服务状态改变）或数据（例如，接收到满足特定模式的数据）。

• 匹配条件（Criteria）：规则中的匹配条件用于确定何时触发规则。这些条件可以基于传入的数据（例如，Webhook 接收到的数据）来定义，只有当数据与指定的模式或值匹配时，规则才会触发。

• 执行操作（Action）：一旦规则被触发，就会执行定义在规则中的动作。动作是执行实际工作的单元，可以是运行一个脚本、发送通知、调用 API 等。

• 工作流（Workflow）：工作流是一系列动作的集合，它们按照特定的顺序执行。工作流可以包含并行执行、决策点（例如，基于条件选择不同的动作）和子工作流。通过工作流，可以将多个动作串在一起，实现更复杂的自动化逻辑。

• CLI、API 或 UI：StackStorm 提供了多种方式来触发操作：

  • 命令行界面（CLI）：使用 st2 命令行工具可以直接从终端触发操作或查询状态。

  • 应用程序编程接口（API）：通过 API，可以在应用程序中集成 StackStorm 的功能，实现远程触发和查询。

  • 用户界面（UI）：StackStorm 的 Web UI 提供了一个图形界面，用户可以通过它来触发操作、查看日志和管理规则等。

• 直接从客户端访问：在某些情况下，你可能希望从客户端应用程序直接触发 StackStorm 的操作。这可以通过使用 API 来实现，客户端应用程序可以发送请求到 StackStorm API，从而触发动作或工作流。

3.3.1 管理和运行操作

• CLI 使用该格式提供对操作管理命令的访问。 要查看可用命令的列表及其说明，请运行：st2 action <command>

[root@StackStorm ~]# st2 action --help
usage: st2 action [-h]
                  {list,get,create,update,delete,clone,enable,disable,execute}
                  ...

An activity that happens as a response to the external event.

positional arguments:
  {list,get,create,update,delete,clone,enable,disable,execute}
                        List of commands for managing actions.
    list                Get the list of actions.
    get                 Get individual action.
    create              Create a new action.
    update              Updating an existing action.
    delete              Delete an existing action.
    clone               Clone a new action.
    enable              Enable an existing action.
    disable             Disable an existing action.
    execute             Invoke an action manually.

optional arguments:
  -h, --help            show this help message and exit
You have mail in /var/spool/mail/root

• 要获取有关特定操作命令的更多信息，请运行：。为 示例，以下内容将为 Action List 命令提供帮助：st2 action <command> -h

[root@StackStorm ~]# st2 action list -h
usage: st2 action list [-h] [-t TOKEN] [--api-key API_KEY] [-j] [-y]
                       [-a ATTR [ATTR ...]] [-w WIDTH [WIDTH ...]] [-p PACK]

Get the list of actions.

optional arguments:
  -h, --help            show this help message and exit
  -t TOKEN, --token TOKEN
                        Access token for user authentication. Get
                        ST2_AUTH_TOKEN from the environment variables by
                        default.
  --api-key API_KEY     Api Key for user authentication. Get ST2_API_KEY from
                        the environment variables by default.
  -j, --json            Print output in JSON format.
  -y, --yaml            Print output in YAML format.
  -a ATTR [ATTR ...], --attr ATTR [ATTR ...]
                        List of attributes to include in the output. "all"
                        will return all attributes.
  -w WIDTH [WIDTH ...], --width WIDTH [WIDTH ...]
                        Set the width of columns in output.
  -p PACK, --pack PACK  Only return resources belonging to the provided pack

3.3.2 修改操作删除 API

• StackStorm 的 API 和 CLI 工具提供了灵活的方式来管理操作（actions）和工作流（workflows）。以下是对您提到的删除操作功能的解释：

• 在 StackStorm 3.6 版本之前：

  • 删除操作的 API 仅从数据库中取消注册操作条目，但不会从磁盘中删除任何文件。

• 从 StackStorm 3.6 版本开始：

  • API 被修改，提供了向后兼容性，并允许用户选择性地从磁盘中删除相关的操作文件。

• CLI 命令：

  • 使用 CLI 删除操作时，可以通过不同的命令选项来决定删除操作的方式：

    • st2 action delete <pack>.<action>：仅从数据库中删除操作条目。

    • st2 action delete --remove-files <pack>.<action>：从数据库中删除操作条目，并从磁盘中删除相关的操作文件。

    • st2 action delete -r <pack>.<action>：这是 --remove-files 的简写形式，效果同上。

• API 方法：

  • 使用 DELETE 方法调用 API 来删除操作，可以通过 JSON 正文中的参数remove_files来指定是否同时删除磁盘上的文件：

    • {"remove_files": true}：删除数据库中的操作条目，并从磁盘中删除相关文件。

    • {"remove_files": false}：仅删除数据库中的操作条目，不删除磁盘上的文件。

• 用法

st2 action delete [-h] [-t TOKEN] [--api-key API_KEY] [-j] [-y] [-r]
                  ref-or-id

• 位置参数：

# Reference or ID of the action
ref-or-id

• 可选参数：

-h, --help            显示此帮助信息并退出
-t TOKEN, --token TOKEN
                      用户认证的访问令牌。默认从环境变量中获取
                      ST2_AUTH_TOKEN
--api-key API_KEY     用户认证的 API 密钥。默认从环境变量中获取
                      ST2_API_KEY
-j, --json            以 JSON 格式打印输出
-y, --yaml            以 YAML 格式打印输出
-r, --remove-files    从磁盘中删除操作文件

3.3.3 克隆操作

动作克隆功能仅在 StackStorm v3.7.0 及更高版本中可用。

• 克隆操作将操作从一个源包克隆到目标包，并相应地重命名它们。此操作会更改目标操作的元数据文件，例如操作名称、包名称、入口点名称等。此外，此操作还会将新克隆的操作注册到数据库。

• API 端点执行源操作。请求方法的主体采用目标包和操作名称。请求方法的主体还采用可选的参数，其类型为布尔值，并且默认为 false。在以下情况下，覆盖标志应为 true：目标操作已存在，并且要被覆盖。

/api/v1/actions/{ref_or_id}/clone
{
  "dest_pack": "目标包名",
  "dest_action": "目标操作名",
  "overwrite": false
}
overwrite: true

• 从 CLI 获取源操作的引用或 ID、目标包名称和目标操作名称作为必需参数。在设计的情况下，如果目标操作已存在，则命令将执行可选的参数或覆盖目标操作。

st2 action clone <ref_or_id> <目标包> <目标操作>

• <ref_or_id> - 源操作的引用或 ID <目标包> - 克隆操作的目标包名 <目标操作> - 克隆操作的目标操作名 -f 或 --force - 可选参数，用于覆盖已存在的目标操作。

解释：

• 克隆操作：在 StackStorm 中，克隆操作允许用户将一个操作从一个包复制到另一个包，并允许用户在复制过程中重命名操作。

• 更改元数据：克隆操作时，操作的元数据（如操作名称、包名称、入口点名称）将被更新以匹配目标包和操作的名称。

• 注册到数据库：克隆后的操作会被注册到 StackStorm 的数据库中，使其可以像其他操作一样被触发和执行。

• API 端点：提供了一个 API 端点来执行克隆操作，可以通过发送 JSON 格式的请求体来指定目标包名、目标操作名和是否覆盖现有操作。

• CLI 命令：StackStorm 的命令行界面（CLI）也提供了一个命令来克隆操作，允许用户指定源操作的引用或 ID、目标包名和目标操作名。如果目标操作已存在，可以使用 -f 或 --force 选项来覆盖它。

用法：

st2 action clone [-h] [-t TOKEN] [--api-key API_KEY] [-j] [-y] [-f]
                 source-ref-or-id dest-pack-name dest-action-name

• 位置参数：

  • source-ref-or-id：源操作的引用或 ID。

  • dest-pack-name：目标包的名称。

  • dest-action-name：目标操作的名称。

• 可选参数：

  • -h, --help：显示此帮助信息并退出。

  • -t TOKEN, --token TOKEN：用户认证的访问令牌。默认从环境变量中获取 ST2_AUTH_TOKEN。

  • --api-key API_KEY：用户认证的 API 密钥。默认从环境变量中获取 ST2_API_KEY。

  • -j, --json：以 JSON 格式打印输出。

  • -y, --yaml：以 YAML 格式打印输出。

  • -f, --force：如果目标存在，则覆盖磁盘上的操作文件。

这个命令用于克隆 StackStorm 中的操作，允许用户将一个已存在的动作复制到另一个包中，并可以指定新的动作名称。使用 -f 或 --force 选项可以在目标操作已存在的情况下强制覆盖。

3.4 动作运行器

在 StackStorm 中，"Action Runners"（动作运行器）是用户实现的动作的执行环境。

• 执行环境：动作运行器提供了一个环境，在这个环境中用户定义的动作可以被执行。

• 预设动作运行器：StackStorm 提供了一些预设的动作运行器，例如：

  • 远程运行器（Remote Runner）：允许用户通过 SSH 在远程主机上执行动作。

  • Shell 运行器（Shell Runner）：允许用户在本地或远程主机上执行 shell 命令或脚本。

• 专注于动作实现：动作运行器的设计目标是让动作的编写者只关注于动作本身的实现，而不需要关心环境的搭建和配置。

• 灵活性和抽象化：动作运行器提供了一层抽象，使得动作可以在不同的环境下执行，而无需修改动作代码。这样提高了动作的可移植性和可重用性。

• 可扩展性：除了预设的动作运行器，StackStorm 还允许用户根据需要实现自定义的动作运行器。

• 环境配置：动作运行器负责处理动作执行所需的环境配置，包括安全设置、依赖管理等。

• 执行管理：动作运行器还负责管理动作的执行，包括启动、监控和终止动作。

3.4.1 Runner动作执行的环境

在 StackStorm 中，"Runner" 定义了动作执行的环境。以下是您提供的可用 Runners 的列表和它们的简要说明：

• local-shell-cmd - 本地运行器，用于在 StackStorm 运行的主机上执行 Linux 命令。

• local-shell-script - 本地运行器，动作以脚本形式实现，它们在 StackStorm 运行的主机上执行。

• remote-shell-cmd - 远程运行器，用于在用户提供的一台或多台远程主机上执行 Linux 命令。

• remote-shell-script - 远程运行器，动作以脚本形式实现，它们在用户提供的一台或多台远程主机上执行。

• python-script - Python 运行器，动作以 Python 类和方法的形式实现，它们在 StackStorm 组件运行的同一台机器上本地运行。动作方法的返回值可以是成功状态标志和结果对象的元组，或者仅仅是结果对象。有关更多信息，请参考文档中的 Action Runners 部分。

• http-request - HTTP 客户端，用于执行 HTTP 请求以运行 HTTP 动作。

• action-chain - 支持执行简单线性工作流的运行器。有关更多信息，请参考 Workflows 和 ActionChain 文档。

• inquirer - 提供 Inquiries 特性核心逻辑的运行器。注意：这个运行器是动作的实现细节，在大多数情况下，不应在其他动作中引用。

• core.ask - 这是一个内部实现细节，用于询问功能，通常不应在动作中直接引用。

• winrm-cmd - WinRM 命令运行器，允许使用 WinRM 协议在 Windows 主机上运行命令行解释器（cmd）命令。

• winrm-ps-cmd - WinRM PowerShell 命令运行器，允许使用 WinRM 协议在 Windows 主机上运行 PowerShell 命令。

• winrm-ps-script - WinRM PowerShell 脚本运行器，允许在 Windows 主机上运行 PowerShell 脚本。

• orquesta - 支持执行复杂工作流的运行器。有关更多信息，请参考 Workflows 和 Orquesta 文档。

每个 Runner 都有自己的输入参数集合。当动作执行时，它会继承 Runner 参数以及它自己的参数。可以在每个动作的基础上覆盖内置参数。

3.5 Action注册

StackStorm是一个开源的事件驱动自动化平台，它允许自动化IT工作流程。以下是根据你提供的步骤注册新操作的一般指南：

• 创建操作文件：首先，你需要创建一个操作文件，通常是YAML格式的元数据文件，例如 my_action_metadata.yaml。这个文件包含了操作的名称、描述、输入参数等信息。

• 放置操作文件：将这个操作文件放入StackStorm的包内容物位置，通常是 /opt/stackstorm/packs 目录下的一个特定包内。如果你的操作是针对黑客攻击的一次性操作，你可以先将其放在 default 包中。

• 注册操作：使用命令行工具来注册这个操作。使用 st2 action create my_action_metadata.yaml 命令来注册单个操作。这里的 my_action_metadata.yaml 是你的操作文件名。

• 重新加载操作：注册操作后，你可能需要重新加载所有的操作以确保它们是最新的。使用 st2ctl reload --register-actions 命令来重新加载操作。

• 测试操作：在默认包中测试你的操作，确保它按预期工作。

• 移动操作到专用包：一旦测试完成，如果这个操作不是一次性的，你应该将其移动到一个专用的包中，以便于管理和维护。

3.6 内置参数

在StackStorm中，动作运行器（Runners）是执行动作（Actions）的组件，它们可以有不同的内置参数。这些参数可以被动作继承，并在动作的元数据中被覆盖，或者在运行动作时通过参数传递来覆盖。以下是一些常见的参数及其用途：

• timeout：这是所有运行器的默认超时设置，其值可能因运行器类型而异。如果操作需要更长的时间来完成，可以在动作元数据中或在运行时覆盖此默认值。

• args：对于local-shell-script和remote-shell-script运行器，args参数用于传递给脚本或命令的参数。StackStorm会根据用户定义的是命名参数还是位置参数来组装参数。

• cmd：对于local-shell-script和remote-shell-script运行器，cmd参数用于配置要在目标系统上执行的命令。

• cwd：对于remote-shell-script运行器，cwd参数用于配置远程命令将从中执行的工作目录。

• env：对于local-shell-script、remote-shell-script、script、python-script等运行器，env参数用于设置环境变量，这些环境变量将可用于执行的命令或脚本。

• dir：对于remote-shell-script运行器，dir参数用于配置目录，脚本将从这个目录在执行之前复制到目标计算机。默认值通常是/tmp。

这些参数可以在动作的元数据文件中设置，例如：

yamlname: my_custom_action
runner_type: local-shell-script
description: My custom action that runs a shell script
enabled: true
entry_point: path_to_script.sh
parameters:
  param1:
    type: string
    default: default_value
  param2:
    type: integer
    default: 123

• 在这个例子中，runner_type指定了动作使用的运行器类型，entry_point是脚本的路径，parameters定义了动作接受的参数及其类型和默认值。

• 要在运行时覆盖这些参数，可以在调用动作时提供它们，例如：

bash
st2 run my_custom_action param1="new_value" timeout=300

• 这将使用新的param1值和300秒的超时时间来运行my_custom_action动作。

4. StackStorm示例

4.1 检测docker服务是否健康

4.1.1 创建action文件

[root@StackStorm ~]# cd /opt/stackstorm/packs/
[root@StackStorm packs]# mkdir -p docker_monitor/actions
[root@StackStorm actions]# cd docker_monitor/actions
[root@StackStorm actions]# cat > check_and_start_docker_service.yaml <<EOF
name: "check_and_start_docker_service"
pack: "docker_monitor"
description: "Check if Docker service is running and start it if not."
runner_type: "local-shell-script"
enabled: true
entry_point: "check_and_start_docker_service.sh" 
EOF

4.1.2 创建脚本

[root@StackStorm actions]# cat > check_and_start_docker_service.sh <<EOF
#!/bin/bash
​
# 检查 Docker 服务状态
if ! systemctl is-active docker &>/dev/null; then
    echo "Docker service is not running. Starting Docker service..."
    sudo systemctl start docker
    if [ $? -eq 0 ]; then
        echo "Docker service started successfully."
    else
        echo "Failed to start Docker service."
        exit 1
    fi
else
    echo "Docker service is running."
fi
EOF
​
[root@StackStorm actions]# chmod +x /opt/stackstorm/packs/docker_monitor/actions/check_and_start_docker_service.sh

• 注册动作

[root@StackStorm actions]# st2 action create check_and_start_docker_service.yaml
[root@StackStorm actions]# st2 action get docker_monitor.check_and_start_docker_service
+---------------+---------------------------------------------------------+
| Property      | Value                                                   |
+---------------+---------------------------------------------------------+
| id            | 66a84cb379433ec5a7874f1f                                |
| uid           | action:docker_monitor:check_and_start_docker_service    |
| ref           | docker_monitor.check_and_start_docker_service           |
| pack          | docker_monitor                                          |
| name          | check_and_start_docker_service                          |
| description   | Check if Docker service is running and start it if not. |
| enabled       | True                                                    |
| entry_point   | check_and_start_docker_service.sh                       |
| runner_type   | local-shell-script                                      |
| parameters    |                                                         |
| metadata_file | actions/check_and_start_docker_service.yaml             |
| notify        |                                                         |
| output_schema |                                                         |
| tags          |                                                         |
+---------------+---------------------------------------------------------+

4.1.3 创建触发器

[root@StackStorm actions]# cd ..
[root@StackStorm docker_monitor]# cat > triggers.yaml <<EOF
---
name: "docker_service_status_check"
pack: "docker_monitor"
description: "Trigger to check Docker service status periodically."
type: "core.st2.IntervalTimer"
parameters:
  interval: 20 
  unit: "seconds"
EOF

# 注册触发器
[root@StackStorm docker_monitor]# st2 trigger create triggers.yaml
[root@StackStorm docker_monitor]# st2 trigger get docker_monitor.docker_service_status_check
+-------------------+---------------------------------------------------------+
| Property          | Value                                                   |
+-------------------+---------------------------------------------------------+
| id                | 66a85445a8d3f307d723dd14                                |
| ref               | docker_monitor.docker_service_status_check              |
| pack              | docker_monitor                                          |
| name              | docker_service_status_check                             |
| description       | Trigger to check Docker service status periodically.    |
| parameters_schema |                                                         |
| payload_schema    |                                                         |
| tags              |                                                         |
| uid               | trigger_type:docker_monitor:docker_service_status_check |
+-------------------+---------------------------------------------------------+

4.1.4 创建规则

[root@StackStorm docker_monitor]# mkdir rules
[root@StackStorm docker_monitor]# cd rules/
[root@StackStorm rules]# cat > check_docker_service_rule.yaml <<EOF
---
name: "check_docker_service_status_every_15_seconds"
pack: "docker_monitor"
description: "Rule to run check_and_start_docker_service action every 15 seconds."
trigger:
  type: "core.st2.IntervalTimer"
  parameters:
    delta: 15
    unit: "seconds"
action:
  ref: "docker_monitor.check_and_start_docker_service"
  parameters: {}
enabled: True
EOF

# 注册规则
[root@StackStorm docker_monitor]# st2 rule rules/create check_docker_service_rule.yaml
[root@StackStorm ~]# st2 rule get docker_monitor.check_docker_service_every_30_seconds
+---------------+-------------------------------------------------------------+
| Property      | Value                                                       |
+---------------+-------------------------------------------------------------+
| id            | 66a84ed4b03debb9dc1820d6                                    |
| uid           | rule:docker_monitor:check_docker_service_every_30_seconds   |
| ref           | docker_monitor.check_docker_service_every_30_seconds        |
| pack          | docker_monitor                                              |
| name          | check_docker_service_every_30_seconds                       |
| description   | Rule to check Docker service status every 30 seconds.       |
| enabled       | False                                                       |
| action        | {                                                           |
|               |     "ref": "docker_monitor.check_and_start_docker_service", |
|               |     "parameters": {}                                        |
|               | }                                                           |
| context       |                                                             |
| criteria      |                                                             |
| metadata_file | rules/check_docker_service_rule.yaml                        |
| tags          |                                                             |
| trigger       | {                                                           |
|               |     "type": "core.st2.IntervalTimer",                       |
|               |     "parameters": {                                         |
|               |         "delta": 30,                                        |
|               |         "unit": "seconds"                                   |
|               |     },                                                      |
|               |     "ref": "core.d63ae6e3-d134-4699-8405-22291bdc4800"      |
|               | }                                                           |
| type          | {                                                           |
|               |     "ref": "standard",                                      |
|               |     "parameters": {}                                        |
|               | }                                                           |
+---------------+-------------------------------------------------------------+

4.1.5 检测

[root@StackStorm ~]# systemctl is-active docker
active
[root@StackStorm ~]# systemctl stop docker
[root@StackStorm ~]# systemctl is-active docker
inactive
[root@StackStorm ~]# sleep 20
[root@StackStorm ~]# systemctl is-active docker
active

# 手动启动方式
[root@StackStorm ~]# st2 run docker_monitor.check_and_start_docker_service

4.1.6 所有问价你的路径

[root@StackStorm ~]# ll /opt/stackstorm/packs/docker_monitor/
total 4
drwxr-xr-x 2 root root  90 Jul 29 22:42 actions
drwxr-xr-x 2 root root  44 Jul 29 22:55 rules
-rw-r--r-- 1 root root 208 Jul 29 22:46 triggers.yaml
[root@StackStorm ~]# cd /opt/stackstorm/packs/docker_monitor/
[root@StackStorm docker_monitor]# ll
total 4
drwxr-xr-x 2 root root  90 Jul 29 22:42 actions
drwxr-xr-x 2 root root  44 Jul 29 22:55 rules
-rw-r--r-- 1 root root 208 Jul 29 22:46 triggers.yaml
[root@StackStorm docker_monitor]# ll actions/
total 8
-rwxr-xr-x 1 root root 395 Jul 29 22:42 check_and_start_docker_service.sh
-rw-r--r-- 1 root root 230 Jul 29 22:14 check_and_start_docker_service.yaml
[root@StackStorm docker_monitor]# ll rules/
total 4
-rw-r--r-- 1 root root 333 Jul 29 22:55 check_docker_service_rule.yaml

4.2 其他节点docker服务是否健康

主机名	IP	功能
StackStorm	192.168.110.100/24	控制端
StackStorm-test-01	192.168.110.101/24	被检测端

4.2.1 创建action文件

[root@StackStorm ~]# cd /opt/stackstorm/packs/
[root@StackStorm packs]# mkdir my_pack/actions -p
[root@StackStorm actions]# cd my_pack/actions/
[root@StackStorm actions]# cat > check_and_start_docker.yaml <<EOF
---
name: "check_and_start_docker"
pack: "my_pack"
description: "Check Docker service on a specific remote host using password and start if not running."
runner_type: "local-shell-script"
enabled: true
entry_point: "check_and_start_docker.sh"
parameters:
  SSH_USER:
    type: "string"
    default: "root"
  SSH_PASSWORD:
    type: "string"
    default: "1234"
    secret: true
EOF

4.2.2 创建检测脚本

[root@StackStorm actions]# cat > check_and_start_docker.sh <<EOF
#!/bin/bash
​
REMOTE_HOST="192.168.110.101"
SSH_USER="root"
SSH_PASSWORD="1234"
​
install_sshpass() {
    echo "Installing sshpass..."
    sudo yum install -y sshpass &>/dev/null
    if [ $? -ne 0 ]; then
        echo "Failed to install sshpass. Please check your yum configuration or install sshpass manually."
        exit 1
    fi
}
​
if ! command -v sshpass >/dev/null 2>&1; then
    install_sshpass
fi
​
if sshpass -p "$SSH_PASSWORD" ssh -o StrictHostKeyChecking=no "$SSH_USER@$REMOTE_HOST" "systemctl is-active --quiet docker"; then
    echo "Docker service is running on $REMOTE_HOST."
else
    echo "Docker service is not running. Attempting to start..."
    if sshpass -p "$SSH_PASSWORD" ssh -o StrictHostKeyChecking=no "$SSH_USER@$REMOTE_HOST" "systemctl start docker"; then
        echo "Docker service started successfully on $REMOTE_HOST."
    else
        echo "Failed to start Docker service on $REMOTE_HOST."
        exit 1
    fi
fi
​
[root@StackStorm actions]# chmod +x check_and_start_docker.sh

4.2.3 注册action

[root@StackStorm actions]# st2 action create check_and_start_docker.yaml

4.2.4 创建rule

[root@StackStorm actions]# cd ..
[root@StackStorm my_pack]# mkdir rules/
[root@StackStorm my_pack]# cd rules/
[root@StackStorm rules]# cat > docker_status_check_rule.yaml <<EOF
---
name: "docker_status_check_rule"
pack: "my_pack"
description: "Rule to check Docker service status every 15 seconds on a remote host."
trigger:
  type: "core.st2.IntervalTimer"
  parameters:
    delta: 15
    unit: "seconds"
action:
  ref: "my_pack.check_and_start_docker"
  parameters:
    SSH_USER: "root"
    SSH_PASSWORD: "1234"
enabled: true
EOF
​
[root@StackStorm rules]# st2 rule create docker_status_check_rule.yaml 

4.2.5 检测

[root@StackStorm-test-01 ~]# systemctl is-active docker
active
[root@StackStorm-test-01 ~]# systemctl stop docker
[root@StackStorm-test-01 ~]# systemctl is-active docker
inactive
[root@StackStorm-test-01 ~]# sleep 10
[root@StackStorm-test-01 ~]# systemctl is-active docker
active

#!/bin/bash
​
REMOTE_HOST="192.168.110.101"
SSH_USER="root"
SSH_PASSWORD="1234"
WEBHOOK_URL="https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=2f953b72-843e-43d3-aa62-1c94980c7956"
​
install_sshpass() {
    echo "Installing sshpass..."
    sudo yum install -y sshpass &>/dev/null
    if [ $? -ne 0 ]; then
        echo "Failed to install sshpass."
        send_webhook_message "Docker服务异常" "Failed to install sshpass."
        exit 1
    fi
}
​
send_webhook_message() {
    local content="$1"
    local extra_content="${2:-}"
​
    curl -X POST "$WEBHOOK_URL" \
         -H 'Content-Type: application/json' \
         -d "{
               \"msgtype\": \"text\",
               \"text\": {
                   \"content\": \"$content\"
               }
             }"
    if [ -n "$extra_content" ]; then
        curl -X POST "$WEBHOOK_URL" \
             -H 'Content-Type: application/json' \
             -d "{
                   \"msgtype\": \"text\",
                   \"text\": {
                       \"content\": \"$extra_content\"
                   }
               }"
    fi
}
​
if ! command -v sshpass >/dev/null 2>&1; then
    install_sshpass
fi
​
if sshpass -p "$SSH_PASSWORD" ssh -o StrictHostKeyChecking=no "$SSH_USER@$REMOTE_HOST" "systemctl is-active --quiet docker"; then
    echo "Docker service is running on $REMOTE_HOST."
else
    echo "Docker service is not running. Attempting to start..."
    send_webhook_message "Docker服务异常" "正在修复"
    if sshpass -p "$SSH_PASSWORD" ssh -o StrictHostKeyChecking=no "$SSH_USER@$REMOTE_HOST" "systemctl start docker"; then
        echo "Docker service started successfully on $REMOTE_HOST."
        send_webhook_message "故障已修复"
    else
        echo "Failed to start Docker service on $REMOTE_HOST."
        send_webhook_message "Docker服务异常" "Docker服务启动失败"
        exit 1
    fi
fi