内容


使用 IBM Pattern Development Kit 构建虚拟应用程序模式,第 1 部分:

创建虚拟应用程序模式插件项目来安装 Tomcat 和 HTTP 服务器

Comments

系列内容:

此内容是该系列 # 部分中的第 # 部分: 使用 IBM Pattern Development Kit 构建虚拟应用程序模式,第 1 部分:

敬请期待该系列的后续内容。

此内容是该系列的一部分:使用 IBM Pattern Development Kit 构建虚拟应用程序模式,第 1 部分:

敬请期待该系列的后续内容。

简介

2013 年 6 月,IBM Pattern Development Kit V1.0.1.0 随 IBM PureApplication System V1.1 一起发布。IBM Pattern Development Kit 软件包可以通过以下方式访问:

IBM Pattern Development Kit (PDK) 软件包中含 Eclipse 插件工具安装文件、虚拟应用程序模式模式开发人员文档,以及 Hello/WASCE 样例项目。IBM PDK for Eclipse 提供了 Eclipse 中的两个透视图:

  • Workload Plug-in Development Perspective:这包括向导、编辑器和实用程序,可以帮助构建、打包和安装虚拟应用程序模式插件项目。
  • Workload Plug-in Runtime Perspective:这包括视图和实用程序,可以查看实例执行日志,上传脚本文件和及恢复挂起的实例。

Apache Tomcat、Apache HTTP Server 和 LiveJournal Memcached 被广泛应用于中小型 Web 项目,它们受到了 Java™ 开发人员和学生的欢迎。使用该软件构建的 Web 平台拓扑既易于理解又让用户感到熟悉,因此使得构造虚拟应用程序模式的学习变得更容易。为了演示模式功能,本系列包括三个部分:

  • 第 1 部分:本文(您正在阅读)提供用户可以配置和部署的单独组件。
  • 第 2 部分:这篇文章将帮助您创建一个组件链接、缩放策略和访问意图策略。第 2 部分提供的链接和策略适用于第 1 部分中所创建的组件,并在部署期间生效。
  • 第 3 部分:这篇文章会帮助您将 Memcached 构建为一个共享服务。它提供了可由多个 Tomcat 服务器实例共享的一个 Memcached 服务器池。

这篇文章还提供了 样例项目 的代码,包括模式类型项目和几个插件项目。请记住,本系列中所使用的项目旨在说明虚拟应用程序模式功能,并演示如何构建插件项目。不过,这些项目也是在 PureApplication System 中高效利用这个开源软件的第一步。

目标场景

Apache Tomcat(或简称 Tomcat)是一个开源的 Java Web 服务器和 Servlet 容器。Apache HTTP 服务器(或简称为 HTTPD)是子版本可以利用的一种 “高强度” 网络服务器。LiveJournal Memcached(或简称为 Memcached)是一个高性能的分布式内存对象缓存系统。在传统的拓扑中,Tomcat 服务器被注册到 HTTPD 服务器,以充当工人,并在 Memcached 中存储 Tomcat 会话数据,让集群环境中失败的 Tomcat 节点可获得恢复。这里提供了三种拓扑(从简单到复杂):

  • 开发(本文及 第 3 部分:分别部署 Tomcat 服务器、HTTPD 服务器或 Memcached 服务器。它们之间没有任何连接,如图 1 所示。
    图 1. 开发部署
    开发部署
  • 测试(第 2 部分第 3 部分 文章):部署一台 HTTPD 服务器、两台 Tomcat 服务器,并将它们连接到一台 Memcached 服务器,如图 2 所示。
    图 2. 测试部署
    测试部署
    测试部署
  • 生产(第 2 部分第 3 部分 文章):使用默认设置,它将部署两台 HTTPD 服务器和四台 Tomcat 服务器,并将它们连接到一台 Memcached 服务器(参见图 3)。
    图 3. 生产部署
    生产部署
    生产部署

创建一个模式类型项目

模式类型项目 是包含插件项目的一个组定义。它可以生成一个完整的包,其中包括所有插件项目以及在插件项目中使用的安装文件。在模式类型项目中,可以定义:

  • patterntype.json 中的模式类型属性,包括名称、缩写名、版本、描述、先决条件(用于模式类型和版本)、类别(用于对显示在模式构建器调色板中的组件进行分组),以及许可(用于跟踪产品的使用情况)。
  • 许可声明文件。
  • “About(关于)” 文件。
  • 内部化消息 JSON 文件,用于显示在 Web 页面中的属性,例如名称、缩写名和描述。

创建样例模式类型项目的步骤

在已安装 IBM Pattern Development Kit 的条件下启动 Eclipse。首先,创建一个新的模式类型项目。

  1. 选中菜单 File > New > Project...> IBM Workload Plug-in Development > IBM Workload Pattern Type Project
  2. 在 New Project 向导中,输入项目名称 patterntype.samples.apache,并让模式类型名称使用相同的名称。
  3. 单击 Finish,此时向导将会生成一个新的模式类型项目的框架(skeleton)。

第二,配置 patterntype.json 中的属性。

  1. 双击 patterntype.json 打开模式类型页面,其中包含以下两个选项卡:Overviewpatterntype.json。Overview 选项卡是一个表单编辑器,而 patterntype.json 选项卡是一个源代码编辑器。
  2. Overview 选项卡 中,可以设置基本信息。表单编辑器立即验证设置,包括验证名称中的禁用字符、版本格式,等等。
  3. 在 Prerequisite 部分中,单击 Add。分别将属性的 Name 和 Version 的值设置为 foundation*。这为所有版本的模式类型基础都创建了一个先决条件。
  4. 在 Categories 部分中,单击 Add。分别将属性的 ID、Label 和 Description 的值设置为 samples.apacheApacheApache
  5. 为了国际化属性名称和描述,首先应采用 JSON 格式定义 message.json 中的键/值对。然后,将 patterntype.json 中的名称和描述属性值替换为相关的键。有个的示例请参见清单 1 和清单 2。此样例模式类型只支持英文,所以只有 "locales/en/messages.json" 文件被更新。
    清单 1. locales/en/message.json 文件
    {
    "PATTERN_TYPE_NAME":"Samples with OpenSources",
    "PATTERN_TYPE_DESC":"This pattern type includes Apache tomcat,
    http server and memcached, which are used as samples.No license/responsibility
    for these"
    }
    清单 2. patterntype.json
    {
       "name":"PATTERN_TYPE_NAME",
       "shortname":"patterntype.samples.apache",
       "version":"1.0.0.0",
       "description":"PATTERN_TYPE_DESC",
       "status":"",
       "prereqs":{
          "foundation":"*"
       },
       "categories":[
          {
             "id":"samples.apache",
             "label":"Apache",
             "description":"Apache"
          }
       ]
    }
  6. 模式类型项目已完成。选择 Window > Preferences > IBM Pattern Toolkit。输入主机名、用户 ID 和您的 PureApplication System 的密码,然后单击 OK。右键单击您的项目。
  7. 在弹出菜单中,选择 IBM Toolkit > Install/Update to Deployer。该工具将会构建项目,并将其安装到目标系统。目前,此模式类型项目没有包含任何插件项目。它只是一个类型定义,无法部署任何东西。

后续工作

有几个特性需要添加到模式类型项目:

  1. 添加许可声明文件。首先,在项目的根文件夹中创建文件夹 licenses。然后,添加名称为 "[language code].html" 的许可内容文件。对于英语,文件名是 “en.html”。
  2. 添加产品 ID 来跟踪产品许可。首先,在 patterntype.json 中声明此产品 ID。第二,在插件项目中的 "vm-templates" JSON 部分设置许可使用。清单 3 显示了 Hel​​lo 样例项目中的样例配置。
    清单 3. 在 patterntype.json 和 VM 模板中的 Product ID
    # Declaration in patterntype.json
    "license":{
        "pid":"5725D65",
        "type":"PVU"
    }
    
    # Usage in VM template which can use more than one license in one VM
    {
        "vm-templates":[
            {
                "name":"${prefix}-HVM",
                "packages":[
                    "Hello",
                    "HCUtils"
                ],
                "roles":[
                    {
                        "plugin":"$provider.PluginScope",
                        "type":"Hello",
                        "name":"Hello",
                        "parms":{
                            "Hello_Sender":"$attributes.sender"
                        }
                    }
                ],
              "licenses":[
                    {
                        "ptype.hello":"2.0"
                    }
                ]
            }
        ]
    }
  3. 为模式类型添加 “关于” 信息。首先,在项目下面创建 "about" 文件夹。然后,添加名为 "[language code].html" 的内容文件。

创建一个 Tomcat 插件项目

此插件项目将:

  • 安装 Tomcat 服务器。下载 Tomcat 安装文件,并将它安装到指定的位置。
  • 配置并启动服务器。运行的 Tomcat 服务器需要一些环境变量,包括 JAVA_HOME 和 CLASS_PATH。此外,通过用户、端口、密码等设置更新配置。
  • 部署用户在构建模式时需要的应用程序。
  • 提供完成实例部署后(包括新的应用程序部署和重新启动服务器)可以在控制台页面中使用的管理操作。

在这个插件项目中,Tomcat 安装二进制文件是 "apache-tomcat-7.0.40.tar.gz",适用于 Linux。下一节将说明如何创建这个项目。

步骤 1:创建一个插件项目框架

该 PDK 提供一个向导,生成一个插件项目框架。

  1. 在 Eclipse 中,选中 File > New > Project...> IBM Workload Plug-in Development > IBM Workload Plug-in Project
  2. 输入项目名为 plugin.com.ibm.samples.tomcat,让插件名称使用相同的名称。单击 Next
  3. 单击 Select the pattern type in workspace 选项。它列出了当前工作区中的所有模式类型。选中 patterntype.samples.apache ,如图 4 所示。
    图 4. 选中一种模式类型
    选中一种模式类型
    选中一种模式类型
  4. 单击 Finish,生成插件项目框架。

    下面显示了所生成的项目框架的结构。这三个文件夹可以被更新,并打包在要导出的 .tgz 文件中:

    • src:这是用于 Java 代码的文件夹。
    • META-INF, OSGI-INF:这是 OSGI 组件定义。
    • plugin:这是插件配置文件、区域设置信息文件、图片、脚本等。

    其他文件夹用于构建、验证和类路径库。

    • build:这将构建脚本和相关的库。
    • lib:这些是 Java 库。
    • build.xml:这提供了打包任务。

备注:如果当前工作区包含 plugin.depends 项目,该项目提供 lib 和 builds 文件夹作为参考,那么新创建的模式插件项目的框架 包含它们。build.patterntype.xml 将导入 plugin.depends 项目中相关的任务定义文件。

步骤 2:配置插件项目

这一步将会配置属性并设置代码框架,将脚本纳入虚拟应用程序模式框架。模式插件项目提供了许多配置文件来定义不同的功能,这些功能包括 config.json、config_meta.json、metadata.json、operation.json、tweak.json、monitoring_ui.json、OSGI 定义文件、VM 模板,等等。在这些文件中,config.json、metadata.json、OSGI 定义文件和 VM 模板是最常用的。在这个项目中,operation.json 还需要定义管理操作。

在 metadata.json 中定义组件和属性

metadata.json 文件定义组件、策略和链接,它们是用来在 PureApplication System 控制台中构建 Virtual Application Builder 的可见元素。开发人员还定义了一些暴露给用户在 Virtual Application Builder 中执行构建操作时进行设置的属性。

该项目定义了一个组件,它执行了 Tomcat 服务器安装。

  1. 双击 plugin/appmodel/metadata.json 文件。这将启动编辑器,它是一个复合编辑器,在不同的选项卡中有常见的配置文件。
  2. 单击 Metadata 部分中的 "+",自动切换到 Application Model 选项卡。在弹出的对话框中,选择组件类型,然后单击 OK
  3. 填写 ID、标签和描述属性。选择在上面的模式类型项目中定义的类别。Image 和 Thumbnail 是用来在 Virtual Application Builder 中表示 Tomcat 服务器的图标图像。浏览并选中图像,也可以让图标使用默认的图像。
  4. 在 Tomcat 服务器中,端口、管理员密码和应用程序包等属性都被暴露给用户进行设置。在 Attributes 部分,单击 Add...,选择类型,并填写每一个属性,如图 5 所示。清单 4 显示了属性定义的详细信息。
    图 5. Tomcat 服务器应用程序模型选项卡
    Tomcat 服务器应用程序模型选项卡
    Tomcat 服务器应用程序模型选项卡
    清单 4. metadata.json 源属性部分
          "attributes":[
             {
                "id":"tomcat.port",
                "type":"string",
                "required": true,
                "label":"TOMCAT_PORT_LABEL",
                "description":"TOMCAT_PORT_DESC",
                "regExp":"[0-9]+",
                "sampleValue":"8080"
             },
             {
                "id":"tomcat.admin.password",
                "type":"string",
                "required": true,
                "displayType":"password",
                "label":"TOMCAT_PASSWORD_LABEL",
                "description":"TOMCAT_PASSWORD_DESC"
             },
             {
                "id":"web_apps",
                "type":"file",
                "required": false,
                "label":"Web Application File (.war or .zip)",
                "description":"For a single application, a .war file is required;
                 For several applications, a .zip file with all .war files is required.",
                "extensions":[
                   "war",
                   " zip"
                ]
             }
          ],

定义部件、角色、包和 config.json

包、部件和角色结构由虚拟应用程序模式框架定义。包是用于部署的单元,它可以包含多个部件。一个部件可以包括多个角色。通常情况下,在角色中使用生命周期脚本来实现部署和配置。在这个项目中,PKG_TOMCAT_INSTALL 包中包含 TOMCAT_INSTALL 和它的 tomcat.install 部件。

  1. 在文件夹部件中,将 “tomcat.scripts” 重​​命名为 “tomcat.install”。然后,在 “tomcat.install” 中删除 uninstall.py,因为不需要执行卸载操作。
  2. 在 tomcat.install/scripts 文件夹中,将 "TOMCAT" 重命名为 “TOMCAT_INSTALL”。要添加一个新的部件或角色:在 metadata.json 编辑器中,切换到 Overview 选项卡。在 Package 部分,可选中节点 Parts 来添加一个部件,或选中一个特定部件来添加 Role,然后单击 Add。或者,选择菜单 File > New > Others… > IBM Workload Plug-in Development > Plug-in Part 或 Plug-in Role
  3. 在 config.json 中,更新包定义,确保属性 part 与模式 "parts/[part folder name].tgz" 相匹配。
  4. 在 config.json 中,设置所需的操作系统和安装文件,如清单 5 所示。
    清单 5. 文件 config.json 源部件
       "packages": {
          "PKG_TOMCAT_INSTALL": [
             {
                "requires": {
                   "arch": "x86_64"
                },
                "parts": [
                   {
                      "part": "parts\/tomcat.install.tgz",
                      "parms": {
                         "installDir": "$INSTALL_DIR"
                      }
                   }
                ]
             }
          ]
       },
       "parms": {
          "INSTALL_DIR": "\/opt\/apache"
       },
       "files": [
          "\/apache\/apache-tomcat-7.0.40.tar.gz"
       ]

定义虚拟机(VM)模板

VM 模板是一个 JSON 片段,它结合使用用户输入以及包和角色来定义 VM 拓扑和在每个 VM 上运行的脚本。虚拟应用程序模式提供了两种构造 VM 模板的方法:基于 Java基于模板。在这个项目中,选择基于 Java 的变换器(它可以处理复杂的逻辑)生成 VM 模板。

  1. 选择菜单 File > New > Other...> IBM Workload Plug-in Development > OSGI Service Component
  2. service type 中,选择 Topology Provider (java based)。然后,填写属性。名称的值必须与目标组件的 ID 相同。
  3. 单击 OK。它将在 OSGi 和类 TomcatTransformer 文件夹下生成 OSGI 定义,该定义扩展了 TopologyProvider(参见清单 6 和清单 7)。
    清单 6. samplestomcat.xml 的 OSGI 定义文件
    <?xml version="1.0" encoding="UTF-8"?>
    <scr:component xmlns:scr="http://www.osgi.org/xmlns/scr/v1.1.0" name="samplesTomcat">;
    	<implementation class="com.ibm.vap.samples.tomcat.TomcatTransformer" />;
    	<service>
    		<provide interface="com.ibm.maestro.model.transform.TopologyProvider" />
    	</service>
    </scr:component>
  4. 在 transformComponent 方法中,目标 JSON 片段被构造为一个返回值(参见清单7)。
    清单 7. transformComponent 方法的一部分
    JSONObject templates = new JSONObject();
    …
    roleTomcat.put(TplSysKeys.PLUGIN, getPluginScope());
    …
    #get attributes defined by users
    JSONObject attributes = (JSONObject) component.get(TplSysKeys.ATTRIBUTES);
    …
    //add storage template
    addStorageTpl(templates);
    addStorageToVM(vm);
    …
    return templates;

    该 TomcatTransformer 方法结合了插件配置和用户设置来构造一个 JSON 片段,以表示在虚拟机中使用的虚拟机模板和存储模板(参见清单 8)。

    清单 8. TomcatTransformer 方法返回的 JSON 片段
    {
        "vm-templates":[
            {
                "packages":[
                    "PKG_TOMCAT_INSTALL"
                ],
                "roles":[
                    {
                        "plugin":"plugin.com.ibm.samples.tomcat/1.0.0.0",
                        "parms":{
                            "tomcat.admin.password":"<xor>PjsyNjE=",
                            "tomcat.port":"8080"
                        },
                        "type":"TOMCAT_INSTALL",
                        "external-uri":[
                            {
                                "Tomcat Console":"http://{SERVER}:8080"
                            }
                        ],
                        "name":"TOMCAT_INSTALL"
                    }
                ],
                "name":"Tomcat_Server-tomcat",
                "storage":[
                    {
                        "storage-ref":"TomcatStorage",
                        "device":"/dev/sdb",
                        "mount-point":"/opt/apache"
                    }
                ]
            }
    ],
        "storage-templates":[
            {
                "parms":{
                    "size":10,
                    "format":"ext3",
                    "type":"auto"
                },
                "name":"TomcatStorage"
            }
        ]
    }

在 operation.json 中定义操作

操作是您可以在实例部署之后运行的管理功能。该项目提供了 “restart(重新启动)” 和 “deploy new application(部署新的应用程序)” 操作。操作定义依附于角色文件夹中的特定角色和实现脚本文件。

  1. 在 metadata.json 编辑器中,切换到 Operation 选项卡。
  2. 单击 Add 按钮,定义重新启动操作,然后输入角色、ID、类别和脚本属性。角色的值是 TOMCAT_INSTALL 的现有角色名称。脚本的值是实现文件名称和方法名称的串联,两个名称之间有一个空格。单击 OK
  3. 单击 Add 按钮定义 "deploy new application" 操作。此操作需要角色、ID、类别和脚本属性,还需要用于上传新应用程序包的文件属性。单击 OK
  4. 在 TOMCAT_INSTALL 角色文件夹下创建一个 operation.py 脚本文件。清单 9 显示了操作定义的详细信息。
    清单 9. Tomcat 插件中的文件 operation.json
    {
       "TOMCAT_INSTALL":[
          {
             "id":"tomcat_restart",
             "label":"Restart Tomcat Server",
             "description":"Restart Tomcat Server",
             "category":"Tomcat Operations",
             "script":"operations.py restart"
          },
          {
             "id":"deploy_apps",
             "label":"Deploy New Application",
             "description":"Deploy New Application",
             "category":"Tomcat Operations",
             "script":"operations.py deploy_apps",
             "attributes":[
                {
                   "id":"new_apps_pkg",
                   "type":"file",
                   "required": true,
                   "label":"New application",
                   "description":"New application",
                   "extensions":[
                      "war",
                      "zip"
                   ]
                }
             ]
          }
       ]
    }

步骤 3:为 Tomcat 构建一个安装和操作脚本

安装或配置脚本包括部件生命周期脚本和角色生命周期脚本,其执行上下文是不同的。在部件生命周期脚本中,属性参数是在 config.json 中定义的。不过,在角色生命周期脚本中,属性参数来自 VM 模板中的角色定义。请注意,部件生命周期脚本在所有角色生命周期脚本之前执行(参见图 6)。

图 6. TOMCAT_INSTALL 生命周期脚本
TOMCAT_INSTALL 生命周期脚本

虚拟应用程序模式提供了 maestro Python 包,在生命周期脚本中用来与虚拟应用程序模式框架进行通信。Maestro 包还包含了一个实用程序模块,用于执行功能,如开启和关闭通过防火墙的端口。该 PDK 包中包括 maestro 包的 API 文档。在每个生成的生命周期脚本的开头处都有一个附加文档,它包括一大段注释,用于描述 maestro 包的最常用方法。

部件生命周期脚本

同一 VM 中的不同部件是按照拓扑配置中定义的顺序执行的。您可以设置各部件之间的依赖关系,让其中一个部件等待另一个部件。不过,在本例中,我们只定义了一个部件。在这个项目中,所提供的 install.py 脚本位于 tomcat.install 部件文件夹下。因为没有卸载要求,所以删除了 uninstall.py 文件。install.py 脚本(参见清单 10)执行以下功能:

  • 将参数从部件范围传递到角色范围。
  • 下载 Tomcat 安装文件。
  • 安装角色脚本。如果部件的生命周期脚本包含角色,那么这是必要步骤。
清单 10. install.py 的一部分
…
import maestro

…
download_dir = maestro.parms['installDir'] + '/download'
part_name = 'tomcat.install'
if not part_name in maestro.node['parts']:
    maestro.node['parts'][part_name] = {}
maestro.node['parts'][part_name]['installDir'] = maestro.parms['installDir']

#download tomcat binary
installer_url = urlparse.urljoin(maestro.filesurl, '/storehouse/admin/files/apache/apache-tomcat-7.0.40.tar.gz')
logger.debug('Download apache-tomcat-7.0.40.tar.gz...')
maestro.download(installer_url, download_dir + '/apache-tomcat-7.0.40.tar.gz')

#install scripts
maestro.install_scripts('scripts')

角色生命周期脚本

角色脚本按以下顺序执行:install.py > configure.py > start.py。不同角色中的生命周期脚本可并行运行。本例中不需要 configure.py 脚本。

  • install.py 包括 Tomcat 安装、端口配置、管理员密码、环境变量声明和 Web 应用程序的安装。install.py 和 configure.py 脚本只在部署期间运行。
  • start.py 包括将角色状态更改为 RUNNING,打开端口,并暴露在启动 VM 时需要的参数。
  • stop.py 处理 Tomcat 服务器的关闭。

Python 对象 maestro.role 可以使用相同的角色在不同的生命周期脚本之间存储​​或传输数据。此外,该角色下的操作实现文件可以访问来自 maestro.role 的数据。本文提供的 可下载样例代码 中包含了更多的详细信息。

操作实现脚本

操作实现文件需要包括两个方法:restartdeploy_apps,它们提供了以下功能:

  • restart:获取 Tomcat 主页,并重新启动 Tomcat。
  • deploy_apps:获取 Tomcat 主页,下载新的应用程序安装文件,并将应用程序移动到 Tomcat webapps,然后重新启动 Tomcat。

创建一个 HTTPD 插件项目

现在是时候创建 HTTPD 插件结构和配置了。对于 HTTPD 安装,可使用 “httpd-2.4.4” 源代码。安装脚本从源代码构建 HTTPD 并安装它。对于 VM 模板定义,该项目选择了基于模板的拓扑提供商,如图 7 所示。

图 7. HTTPD 插件项目中的新 OSGI 组件
HTTPD 插件项目中的新 OSGI 组件
HTTPD 插件项目中的新 OSGI 组件

单击 Finish。除了 OSGI 组件定义之外,PDK 还在 “templates/sampleshttpd.vm” 中生成一个虚拟机快速模板的基本 JSON 片段(参见清单 11)。JSON 结构清晰,您可以利用由 maestro 提供的预定义对象来构建此模板。它比基于 Java 的模板更简单、更清晰。然而,它有一个限制,不能像 Java 代码变换器一样轻松地处理复杂的逻辑。

清单 11. 在 HTTPD 插件中的 sampleshttpd.vm
{
    "vm-templates":[
        {
            "persistent":false,                 
            "name":"${prefix}-httpd",
            "roles":[
                {
                	"plugin" :"$provider.PluginScope",
                    "parms":{
                    },
                    "type":"HTTPD_INSTALL",
                    "name":"HTTPD_INSTALL",
                    "external-uri":[{"ENDPOINT":"http://{SERVER}"}]
                }
            ],
            "packages":[
                "PKG_HTTPD_INSTALL"
            ]
        }
    ]
}

构建并安装一个模式类型和插件

PDK 提供了一个菜单,直接在 PureApplication System 中构建和安装模式类型项目。在第一次安装时,Tomcat 和 HTTPD 安装文件没有被上传到 PureApplication System 中的 Storehouse。这些安装文件可以与模式类型项目一起打包,而且只需要上传一次。

  1. 在模式类型项目中找到 "build.patterntype.xml"。右键单击文件。选择菜单 Run As > Ant Build。切换到 Main 选项卡,在 ant build 中设置 "storage.dir (local)" 或 "storage.url (remote)" 参数,所使用的文件夹或 URL 中应包含此模式类型的所有插件项目的 config.json 中的已定义文件(例如,Dstorage.dir=d:/files)。单击 OK 进行构建。模式类型构建版本也打包了其插件项目。

    备注:安装文件的打包只适用于模式类型的第一个构建版本。

  2. 右键单击模式类型项目选择菜单 IBM Pattern Toolkit > Install/update to deployer
  3. 在第一次时,会弹出一个工具箱首选项页面,用于设置部署器的连接属性。设置 PureApplication System 属性,然后选中 Deploy debugging plug-ins before deployment 复选框,安装调试插件和解锁插件,供以后进行调试。
  4. 以下内容被安装到 PureApplication System:模式类型项目、Tomcat、HTTPD 插件项目和文件。
  5. Project Explorer 视图工具栏中,单击 Navigator to Deployer 按钮。这将启动一个外部浏览器来登录到 PureApplication System。

在控制台中启用该模式类型,然后使用它将实例部署到云。

使用 PDK 进行调试

PDK 包括一个调试插件,为虚拟应用程序模式的开发提供调试功能。以下过程使用调试插件来调试 Tomcat 插件项目。

  1. 登录到 PureApplication System 控制台,并选择菜单 Patterns > Virtual Applications。然后单击 "+"。
  2. 在弹出的对话框中,选中模式类型 patterntype.samples.apache,单击 Start building 按钮,打开虚拟应用程序构建器。
  3. 从组件面板,将 Tomcat Server 组件和调试组件拖动到画布(图 8)。然后,设置在 Tomcat Server 组件中所需的属性。
    图 8. Virtual Application Builder 中的构建模式
    Virtual Application Builder 中的构建模式
    Virtual Application Builder 中的构建模式

    调试插件有两种调试模式:

    • 模拟部署:已部署的实例执行变换器/提供者,生成 topology.json,但不部署虚拟机。
    • 用于手动调试的部署:选中 Resumable on script error 复选框,在脚本执行过程中,如果出现错误,则启用实例挂起。然后,您可以更新脚本并恢复实例的执行。如果没有调试插件,则必须重新部署实例来测试被更新的脚本。
  4. 切换回 Virtual Applications 页面。选中新创建的模式,然后单击 Deploy 按钮。在弹出的对话框中,展开 Advanced 部分,设置 SSH 密钥,并确保将它被保存为一个私钥。然后单击 OK 部署这个模式。

现在,正在运行一个包含 Tomcat 服务器插件的实例。在 PDK 中,切换到 Workload Plug-in Runtime 视图,跟踪实例的执行和调试,如下所示:

  1. Deployment Runtime Explorer 中,单击 "+"。
  2. 在弹出的对话框中,选中 Add VM(s) from deployed instance 单选按钮,跟踪完整的实例。单击 Next
  3. 这里列出了所有虚拟应用程序模式实例。选中新部署的实例。然后,单击 SSH Configuration 按钮,设置 SSH 属性。选中 Key Mode 并设置 SSH 密钥文件位置,如图 9 所示。单击 OK
    图 9. 启用了自动监控器的 SSH 配置
    启用了自动监控器的 SSH 配置
    启用了自动监控器的 SSH 配置
  4. 单击 Finish 添加此实例,它是被监控的实例。日志被自动收集,直到部署完成或不再出现错误。在本例中,install.py 角色脚本包含一个错误,这会暂停该实例的执行,如图 10 所示。
    图 10. install.py 中的执行错误
    install.py 中的执行错误
    install.py 中的执行错误
  5. 如果要继续前进,则需要修复 “install.py” 中的错误。然后,在 Deployment Runtime Explorer 日志树视图中右键单击错误节点。选择 Upload And Resume 菜单。它将在 VM 上更新 install.py,并恢复该实例的执行。您可以重复这个过程来修复所有错误,并完成执行。有些错误是不可恢复的,这意味着您需要更新插件,并重新部署一个实例来进行调试。
  6. 在控制台中,在虚拟应用程序实例上单击 TOMCAT_INSTALL 端点。这将打开 Tomcat 服务器管理控制台,您可以在这里验证安装。

现在测试如上所述的 HTTPD Server 插件,确保 HTTPD 插件可以正确地安装 HTTPD 服务器。

下载文件

请参阅提供的 样例代码,以获得 samples.apache。下载软件包,并从菜单中选择 File > Import… > IBM Workload Plug-in Development > IBM Workload Pattern type Package,导入项目。

结束语

本系列的第 1 部分向您展示了如何开发一个包括 Apache Tomcat 和 Apache HTTPD 服务器插​​件组件的虚拟应用程序模式。您还学习了如何构建、部署和调试模式。

第 2 部分 中,您将创建一个链接和策略,它会影响组件部署。在 第 3 部分 中,您将创建共享服务,提供由多个 Tomcat 服务器实例共享的一个 Memcached 服务器池。


下载资源


相关主题


评论

添加或订阅评论,请先登录注册

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=10
Zone=Cloud computing
ArticleID=963562
ArticleTitle=使用 IBM Pattern Development Kit 构建虚拟应用程序模式,第 1 部分:: 创建虚拟应用程序模式插件项目来安装 Tomcat 和 HTTP 服务器
publish-date=02202014