Openshift-秘籍-全-

Openshift 秘籍（全）

原文：annas-archive.org/md5/7320f539efdfdc3ef301be2659f9986e

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

OpenShift 是一个由 Red Hat 推出的开源、多语言支持、可扩展的云平台即服务（PaaS）。在写作时，OpenShift 正式支持 Java、Ruby、Python、Node.js、PHP 和 Perl 编程语言运行时，以及 MySQL、PostgreSQL 和 MongoDB 数据库。它还提供了 Jenkins CI、RockMongo、Mongo Monitoring Service 代理、phpMyAdmin 以及许多其他功能。由于 OpenShift 具有可扩展性，开发者可以通过添加对当前 OpenShift 不支持的运行时、数据库和其他服务的支持来扩展它。开发人员可以通过命令行工具、IDE 集成或 Web 控制台来使用 OpenShift。OpenShift 使用一个名为 Git 的流行版本控制系统来管理应用程序的部署。OpenShift PaaS 使得云端 Web 应用程序的开发变得更加简便。部署现有或新应用程序到 OpenShift 非常直接。全球许多开发者正在利用 OpenShift 的功能来加速开发和部署。

开始使用 OpenShift 很容易，但就像许多我们用来开发 Web 应用程序的工具一样，可能需要一些时间才能真正领略 OpenShift 的全部功能。OpenShift 平台及其客户端工具充满了你可能从未想过的功能。一旦你了解它们，它们将使你更加高效，并有助于编写可扩展的 Web 应用程序。

OpenShift Cookbook 以简明易懂的方式展示了 100 多个实例。它将带领你学习多个实例，展示 OpenShift 的特性，并演示如何在上面部署特定的技术或框架。你可以快速学习并立即开始在 OpenShift 上部署应用程序。该手册还涵盖了水平扩展、应用程序日志记录和监控等主题。所覆盖的实例解决了在 OpenShift 上有效运行应用程序时常遇到的常见问题。假设读者已经熟悉 PaaS 和云计算的概念。此书不需要从头到尾阅读，允许读者选择自己感兴趣的章节和实例。OpenShift Cookbook 是一本易读的书，充满了实用的实例和有帮助的截图。

本书内容概述

第一章，开始使用 OpenShift，首先介绍了 OpenShift 及如何创建 OpenShift Online 账户。你将使用 Web 控制台创建你的第一个 OpenShift 应用程序，并了解常见的 OpenShift 术语，如“齿轮”和“卡带”。Web 控制台通常是开发人员使用的 OpenShift 主要界面。本章还讨论了如何安装 rhc OpenShift 命令行工具以及如何使用它执行基本操作。

第二章, 管理域名，讨论了域名和命名空间的概念。你将学习如何执行诸如创建、重命名、查看和删除域名等操作。此外，本章还介绍了成员身份的概念，帮助团队协作。

第三章, 创建和管理应用程序，介绍了如何使用 rhc OpenShift 命令行工具创建应用程序。rhc 命令行客户端是与 OpenShift 交互的最强大方式。你将学习如何执行各种应用程序管理操作，如启动、停止、清理和删除应用程序，并使用 rhc 进行管理。还将讨论 OpenShift 的高级功能，如部署跟踪、回滚、配置二进制文件和源代码部署。此外，你还将学习如何为 OpenShift 应用程序使用自己的域名。

第四章, 使用 MySQL 与 OpenShift 应用程序，教读者如何将 MySQL 数据库与他们的应用程序一起使用。还将介绍如何更新默认的 MySQL 配置以满足应用程序的需求。

第五章, 使用 PostgreSQL 与 OpenShift 应用程序，提供了一些示例，展示如何开始使用 OpenShift 的 PostgreSQL 数据库组件。你将学习如何添加和管理 PostgreSQL 组件，备份 PostgreSQL 数据库，列出并安装 PostgreSQL 扩展，并使用 EnterpriseDB PostgreSQL 云数据库服务与 OpenShift 应用程序配合使用。

第六章, 使用 MongoDB 和第三方数据库组件与 OpenShift 应用程序，提供了多个示例，展示如何开始使用 OpenShift 的 MongoDB 组件。你还将学习如何使用 MariaDB 和远程字典服务器（Redis）等可下载组件。

第七章, OpenShift for Java 开发者，介绍了 Java 开发者如何有效使用 OpenShift 开发和部署 Java 应用程序。你将学习如何在 OpenShift 上部署 Java EE 6 和 Spring 应用程序。OpenShift 与各种 IDE 有着一流的集成，因此你将学习如何使用 Eclipse 来开发和调试 OpenShift 应用程序。

第八章，Python 开发者的 OpenShift 指南，讲解了 Python 开发者如何有效地使用 OpenShift 开发和部署 Python 应用程序。本章将教你如何在 OpenShift 上开发 Flask 框架的 Web 应用程序。你还将学习如何管理应用程序的依赖，访问应用程序的 virtualenv，并使用独立的 WSGI 服务器，如 Gunicorn 或 Gevent。

第九章，Node.js 开发者的 OpenShift 指南，介绍了如何使用 OpenShift 构建 Node.js 应用程序。你将学习如何使用 Express 框架构建 Web 应用程序。本章还将介绍如何使用 npm 管理应用程序依赖，如何使用 WebSocket，以及如何在 OpenShift Node.js 应用程序中使用 CoffeeScript。

第十章，OpenShift 应用程序的持续集成，教你如何与 OpenShift 应用程序进行持续集成。你将学习如何将 Jenkins 插件添加到应用程序中，并自定义 Jenkins 任务以满足需求。本章还介绍了如何安装 Jenkins 插件，构建托管在 GitHub 上的项目，并为 OpenShift 应用程序定义自定义 Jenkins 工作流。

第十一章，日志记录与扩展 OpenShift 应用程序，包含了有助于处理应用程序日志的方案。你将学习如何创建自动可扩展的应用程序。你将学习如何禁用自动扩展，并使用 rhc 命令行工具手动扩展 OpenShift 应用程序。

附录，在虚拟机上运行 OpenShift，解释了如何在虚拟化环境中运行 OpenShift 实例。

本书所需的内容

所有的示例都包含了每个方案所需的工具参考。预计你是一个熟练的 Web 开发人员，精通所使用的 Web 框架。你应该具备 Git 和 Bash 的基本知识。如果你是 Java 开发人员，你需要最新版本的 Java 和 Eclipse。如果你是 Python 开发人员，你需要 Python、virtualenv 和一个文本编辑器。如果你是 Node.js 开发人员，你需要 Node.js 和一个文本编辑器。

本书适合谁阅读

本书面向那些希望使用 OpenShift 构建下一个大创意的读者。读者可能是已经在使用 OpenShift 或计划将来使用它的 web 开发者。书中的配方提供了完成各种任务所需的信息。假设你已经熟悉你希望用来开发 web 应用程序的编程语言中的 web 开发。例如，如果你是 Java 开发者，那么你应该已经掌握了 Java EE 或 Spring 的基础知识。本书不会涉及 Java EE 或 Spring 的基础内容，而是讲解如何在 OpenShift 上部署 Java EE 或 Spring 应用程序。

约定

本书中，你会看到多种文本样式，用于区分不同类型的信息。以下是一些样式的示例，以及它们的含义说明。

文本中的代码词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 账号显示如下：“代替 osbook，消息将引用你的域名。”

代码块的格式如下：

[remote "origin"]
  url = ssh://52bbf209e0b8cd707000018a@myapp-osbook.rhcloud.com/~/git/blog.git/
  fetch = +refs/heads/*:refs/remotes/origin/*

任何命令行输入或输出都如下所示：

$ ssh 52b823b34382ec52670003f6@blog-osbook.rhcloud.com ls
app-deployments
app-root
git
mysql
php
phpmyadmin

新术语 和 重要词汇 会以粗体显示。你在屏幕上、菜单或对话框中看到的词汇会像这样出现在文本中：“点击 I Accept 按钮，浏览器将重定向到入门网页。”

注意

警告或重要说明会以框的形式出现。

提示

小贴士和技巧会像这样显示。

读者反馈

我们始终欢迎读者的反馈。请告诉我们你对本书的看法——你喜欢哪些内容，或是不喜欢哪些内容。读者的反馈对我们开发能真正为你带来最大收益的书籍至关重要。

若想给我们提供一般反馈，请发送电子邮件至 <feedback@packtpub.com>，并在邮件主题中提到书名。

如果你在某个领域具有专业知识，并且有兴趣为书籍撰写或贡献内容，请参见我们在 www.packtpub.com/authors 上的作者指南。

客户支持

既然你已经成为了 Packt 图书的骄傲拥有者，我们提供了许多帮助你从购买中获得最大收益的内容。

下载示例代码

你可以从你的账户中下载所有已购买的 Packt 图书的示例代码文件，网址为 www.packtpub.com。如果你是从其他地方购买的本书，你可以访问 www.packtpub.com/support 并注册，将文件直接通过电子邮件发送给你。

勘误

虽然我们已经尽一切努力确保内容的准确性，但错误偶尔还是会发生。如果您在我们的任何一本书中发现错误——可能是文本或代码的错误——我们将不胜感激您向我们报告。通过这样做，您可以避免其他读者的挫折，并帮助我们改进此书的后续版本。如果发现任何勘误，请访问 www.packtpub.com/support，选择您的书籍，点击勘误提交表单链接，输入您的勘误细节。一旦您的勘误被验证，您的提交将被接受，并且勘误将被上传到我们的网站，或者添加到该书籍的现有勘误列表中的勘误部分。

盗版

在互联网上盗版版权材料是所有媒体的长期问题。在 Packt，我们非常重视版权和许可的保护。如果您在互联网上发现我们作品的任何形式的非法副本，请立即向我们提供位置地址或网站名称，以便我们采取补救措施。

请联系我们，使用链接到疑似盗版材料的地址<copyright@packtpub.com>。

我们感谢您帮助保护我们的作者，以及我们为您带来有价值内容的能力。

问题

如果您在书籍的任何方面遇到问题，请联系我们，您可以发送电子邮件至<questions@packtpub.com>，我们将尽力解决。

第一章。开始使用 OpenShift

本章展示了多个教程，向你展示如何使用 Web 控制台和rhc命令行客户端开始使用 OpenShift。你将学习如何通过点击按钮托管自己的 WordPress 博客，如何进行源代码更改并部署它们，以及如何使用rhc命令行客户端执行基本操作。本章的具体教程包括：

创建 OpenShift Online 账户
使用 Web 控制台创建 OpenShift 域
使用 Web 控制台创建 WordPress 应用程序
使用 Web 控制台上传 SSH 密钥
使用 SSH 密钥密码短语
将应用程序克隆到本地机器
部署你的首次变更
检查应用程序的 gear 配额和限制
安装 OpenShift rhc 命令行客户端
使用 rhc 设置 OpenShift 账户
在 rhc 命令行客户端中启用自动完成功能
使用 rhc 查看账户详情
指定不同的 OpenShift 服务器主机名
更新 rhc

OpenShift 简要介绍

几年前，我想写一个 Web 应用程序，处理关于一部电影的推文流，并输出整体情感分析。这可以帮助我决定是否应该观看一部电影。所以，我研究了一个托管服务提供商，发现我可以从 Amazon 租用几台虚拟机来托管我的 Web 应用程序。这是我进入云计算世界的开始。云计算允许访问共享池的计算资源（包括硬件和软件），这些资源通过网络作为服务提供，采用按需付费、弹性扩展（即可以上下调整规模）和按需使用的模式。云计算有三种交付模型：

基础设施即服务（IaaS）：这是最基本的交付模型，用户可以配置计算、存储和其他资源（如网络）来运行应用程序，但用户必须安装并管理运行该应用程序所需的应用程序堆栈。IaaS 的例子包括 Amazon EC2、Google Compute Engine 和 Rackspace。
平台即服务（PaaS）：PaaS 为开发者提供一个应用程序开发平台，帮助他们利用平台提供的运行时、工具、库和服务来构建应用程序。PaaS 的例子包括 OpenShift、Cloud Foundry 和 Heroku。
软件即服务（SaaS）：SaaS 是一组在云端运行的应用程序（或软件），作为服务提供给用户。SaaS 的例子包括 Google Apps 和 Microsoft Office 365。

作为开发者，我喜欢 PaaS 的概念，因为它使我能够将技能集中于应用程序代码，只需关注代码编写，其他的如应用程序堆栈和基础设施管理则交给他人处理。

OpenShift 是一个开源的、多语言支持的、可扩展的 PaaS 平台，由 Red Hat 提供。撰写本书时，OpenShift 官方支持 Java、Ruby、Python、Node.js、PHP 和 Perl 编程语言运行时，支持 MySQL、PostgreSQL 和 MongoDB 数据库，并提供众多其他功能。除了所有支持的服务，OpenShift 用户还可以通过市场（marketplace.openshift.com/home）尝试并使用由不同合作伙伴管理的其他云服务。合作伙伴支持的服务包括数据库服务，如可扩展的 PostgreSQL 作为服务（ElephantSQL），以及 SendGrid 的电子邮件服务。

OpenShift 是一个涵盖三个子项目的大平台，这三个子项目以不同的方式将 OpenShift 技术交付给用户、开发者和社区成员。每个子项目的描述如下：

OpenShift Origin：OpenShift Origin 是一个开源项目，采用 Apache License 2.0 协议，并由社区支持，它是 OpenShift 的上游源项目，供 OpenShift Online 和 OpenShift Enterprise 使用。该项目可在 GitHub 上找到，网址为github.com/openshift。
OpenShift Online：OpenShift Online 是 OpenShift 的公共管理版本。它运行在 Amazon EC2 上，使用经过硬化和稳定的 OpenShift Origin 版本。每个 OpenShift Online 用户都可以享受一个免费计划，该计划允许用户访问三台小型实例，配备 512 MB 的 RAM 和 1 GB 的磁盘空间。OpenShift Online 还可以通过 Bronze 和 Silver 计划作为商业服务提供。商业计划允许用户获得更多资源、存储空间和 Red Hat 专业支持。你可以在www.openshift.com/products/pricing了解 OpenShift Online 的定价。
OpenShift Enterprise：OpenShift Enterprise 是由 Red Hat 全面支持的私有 PaaS 解决方案，可以运行在企业硬件上。OpenShift Enterprise 可以帮助企业提高敏捷性，满足其业务应用需求。

本书将主要聚焦于 OpenShift Online，但所有的操作示例适用于这三个版本。

作为开发者，你可以通过以下四种方式与 OpenShift 进行交互：

Web 控制台：这是使用 OpenShift 的最简单方式，因为它不要求你在机器上安装任何软件。你可以登录 Web 控制台并开始创建应用程序。在撰写本书时，Web 控制台缺少命令行工具中的所有功能。
rhc 命令行工具：这是一个与 OpenShift 交互的命令行工具，作为 Ruby gem 提供。它是与 OpenShift 交互的最强大方式，因为它暴露了所有 OpenShift 的功能。
IDE 集成：如果你是一个喜欢在 IDE 中进行大部分编码的开发人员，那么你会很高兴地知道 OpenShift 与多种 IDE（如 Eclipse、IntelliJ IDEA、Zend Studio 和 Titanium Studio）有着一流的集成。
REST API：你可以使用 OpenShift REST API 编写自己的客户端。你可以使用此 API 为 IDE（如 NetBeans）编写插件，或编写另一个命令行客户端。你可以在access.redhat.com/knowledge/docs/en-US/OpenShift/2.0/html-single/REST_API_Guide/index.html查看 REST API 文档。

重要的 OpenShift 组件如下图所示：

如上图所示，开发人员通过其中一个客户端接口与 OpenShift 进行交互，即 Web 控制台、rhc命令行客户端或 IDE 支持。OpenShift 有以下三个主要组件：

Broker：所有客户端通过代理使用一个定义明确的 REST 接口与代理进行交互。代理负责所有的应用管理活动。它是一个基于 Ruby on Rails 的应用程序，负责管理用户登录、DNS 管理和一般的应用编排。
Node：这是一组 RHEL 实例，提供多租户环境以供最终用户应用使用。
Gear：Gear 是一个在节点内部运行的安全容器，用于托管用户应用。它受到 CPU、磁盘空间和内存的限制。

注意

代理和节点使用 ActiveMQ 消息队列进行通信。它们都安装了 MCollective 客户端，以便互相发送指令。

现在你已经了解了 OpenShift 是什么，以及如何使用它，接下来让我们开始第一章。本章提供了一系列教程，帮助你快速掌握必要的知识，使用 OpenShift 创建云应用。你将学习如何通过 Web 控制台创建第一个 OpenShift 应用，使用 Git 克隆应用，进行第一次源代码修改，并最终将该修改部署到 OpenShift。如果这是你第一次使用 OpenShift，你会惊讶于在 OpenShift 上创建和部署应用的速度。本章还将介绍如何安装rhc命令行客户端，并使用它执行一些基本操作。

创建 OpenShift Online 账户

在本教程中，你将学习如何创建一个 OpenShift Online 账户。你可以免费注册 OpenShift Online 账户；所需的只是一个有效的电子邮件地址。

准备工作

创建 OpenShift Online 账户时，你需要一个 Web 浏览器和一个有效的电子邮件地址。

如何操作…

按照以下步骤创建 OpenShift Online 账户：

打开一个网页浏览器，访问注册页面 www.openshift.com/app/account/new。
输入创建新账户所需的详细信息，然后提交表单。
注册后，你将收到一封包含验证链接的电子邮件。点击验证链接以验证你的电子邮件地址。这将会将浏览器重定向到一个网页，要求你接受使用 OpenShift Online 的法律条款，如下所示的截图所示：
点击 我接受 按钮，浏览器将重定向到入门网页。

注意

如果你没有收到验证电子邮件，请确保检查你的 垃圾邮件 文件夹。

如何工作…

在本配方中，你学习了如何创建一个 OpenShift Online 账户。从用户的角度来看，OpenShift Online 是开始使用 OpenShift 最简单的方式，因为你无需部署和管理自己的 OpenShift 安装。

当你注册 OpenShift Online 时，你将与一个免费计划关联。写本书时，Red Hat 会给每个用户提供三个免费硬件资源，用于运行应用程序。硬件资源提供了一个受限的容器来运行一个或多个应用程序模块。应用程序模块提供了运行应用程序所需的实际功能。OpenShift Online 当前支持许多应用程序模块，如 JBoss、Tomcat、PHP、Ruby、Python、MongoDB、MySQL 等。硬件资源为应用程序模块提供内存和磁盘空间。写本书时，每个硬件资源有 512 MB 的内存和 1 GB 的磁盘空间。用户可以升级到 Bronze 或 Silver 计划，以获取更多和更大的资源。你可以参考 www.openshift.com/products/pricing for up to date information 来获取最新的定价信息。

另见

使用 Web 控制台创建 OpenShift 域 配方
使用 Web 控制台创建 WordPress 应用程序 配方

使用 Web 控制台创建 OpenShift 域

创建 OpenShift Online 账户后，第一步是创建一个域。域或命名空间是应用程序的逻辑容器。它是应用程序 URL 的一部分，并且在一个账户中是唯一的。在本配方中，你将学习如何使用 Web 控制台创建一个域。

准备工作

打开 OpenShift Online 登录页面 openshift.redhat.com/app/login 在你喜欢的网页浏览器中，然后使用你的 OpenShift Online 凭证登录。

如何操作…

要创建一个域或命名空间，请访问账户设置网页 openshift.redhat.com/app/console/settings，并输入一个唯一的名称。域或命名空间在所有用户中应该是唯一的。这意味着你不能使用 osbook 作为域名，因为与本书相关联的 OpenShift 账户已经使用了 osbook。

点击保存按钮以创建一个新域名，如下截图所示：
在域名创建后，你会看到屏幕上显示一条消息，域名 'osbook' 已创建。其中的 osbook 会被替换为你的域名。

它是如何工作的……

OpenShift 要求你在创建应用程序之前先拥有一个域名。域名是 OpenShift 帐户下应用程序的逻辑容器。所有 OpenShift 应用程序必须属于一个域名。每个域名在所有 OpenShift 用户中都是唯一的，并且是应用程序 URL 的一部分。例如，如果你的应用程序名称是myapp，域名是osbook，那么你的应用程序 URL 将是http://myapp-osbook.rhcloud.com。一个域名最多可以包含 16 个字母数字字符，不能包含空格或符号。有时它也被称为命名空间。

用户可以加入其他 OpenShift 用户创建的域名。这允许用户以团队的方式工作。根据 OpenShift 计划或配置，用户可以创建多个域名。免费计划不允许用户创建多个域名，但你仍然可以加入其他域名。我们将在第二章中详细讨论域名，管理域名。

你可以在应用程序设置网页上查看创建的域名，网址为openshift.redhat.com/app/console/settings。如下截图所示：

还有更多内容…

在这个配方中，你学会了如何使用网页控制台创建域名。你可以通过点击域名链接查看域名的详细信息。以下截图展示了域名的详细信息：

在前面的截图中，你可以看到没有任何应用程序与此域名关联。根据免费计划配置，你只能使用小型设备。如果你取消选中允许小型设备复选框，那么你将无法创建任何应用程序。你还可以通过点击添加成员…链接邀请其他用户加入你的域名。团队协作将在第二章中详细讲解，管理域名。你也可以通过点击删除此域名…按钮来删除域名。

另见

第二章中的使用 rhc 创建域名配方，管理域名
第二章中的使用 rhc 查看域名详细信息配方，管理域名
第二章中的使用 rhc 将编辑成员添加到域名配方，管理域名

使用网页控制台创建 WordPress 应用

在本食谱中，您将通过网页控制台创建您的第一个 OpenShift 应用程序。如简介部分所述，网页控制台是 OpenShift 的一个 Web 界面，开发者可以利用它快速创建和管理应用程序。您将使用 OpenShift 的 WordPress 快速启动来创建一个完全配置的应用程序。如果您还没有博客，现在是时候为自己创建一个免费的个人博客了。

准备工作

在您喜欢的网页浏览器中打开openshift.redhat.com/app/login的登录网页，并使用您的 OpenShift 凭证登录。

如何操作…

按照以下步骤通过网页控制台创建 WordPress 应用程序：

访问openshift.redhat.com/app/console/applications的应用程序网页，并点击立即创建您的第一个应用程序链接。
在即时应用部分，点击WordPress 3.9即时应用。本文书写时，WordPress 的版本是 3.9，如下图所示：
输入博客名称并点击创建应用程序按钮。我使用blog作为 WordPress 应用程序的名称，如下图所示：
应用程序创建完成后，您将被引导到一个页面，展示 MySQL 连接的详细信息。您可以通过点击继续查看应用程序概览页面来查看新创建的应用程序详情。
您的 WordPress 博客现在可以在http://blog-{domain-name}.rhcloud.com/运行。将{domain-name}替换为您的 OpenShift 账户域名。

它是如何工作的…

快速启动是一个预配置的 OpenShift 应用程序，它提供了一种可重复的方式，通过源代码和依赖项（如数据库）快速创建一个应用程序。您可以在www.openshift.com/quickstarts查看积极维护的快速启动列表。请注意，OpenShift 团队不支持这些快速启动。它们仅帮助您在 OpenShift 上运行您喜爱的项目（主要是开源项目）。在本食谱中，您使用 WordPress 快速启动来快速搭建一个 WordPress 应用程序。您在网页控制台中选择了 WordPress 3.x 快速启动并给它起了个名字。应用程序名称最多可以包含 32 个字母数字字符。WordPress 快速启动使用一个公共的 Git 仓库，该仓库安装 WordPress 应用程序。它还定义了所使用的组件。WordPress 快速启动使用 PHP 5.3 和 MySQL 5.1 组件。

要创建一个应用程序，点击创建应用程序按钮。这将为我们创建一个名为 gear 的应用程序容器，并设置所有必要的 SELinux 策略和 cgroups 配置。OpenShift 还将使用 quickstart 公共 Git 仓库来设置一个私有 Git 仓库。它将在应用程序 gear 上安装 MySQL 数据库。quickstart 源代码通过环境变量引用 MySQL 数据库。你将在第三章，创建和管理应用程序中学习有关 OpenShift 应用程序的详细信息。

最后，OpenShift 将传播 DNS 到外部世界。该应用程序将可以通过http://blog-{domain-name}.rhcloud.com/访问。将{domain-name}部分替换为你自己独特的 OpenShift 域名，通常也称为命名空间。在你最喜欢的浏览器中打开http://blog-{domain-name}.rhcloud.com/链接并设置你的 WordPress 安装。设置完成后，你将拥有自己的 WordPress 博客并可以开始写博客。

还有更多…

在本教程中，你学习了如何使用 OpenShift Web 控制台创建一个 WordPress 应用程序。你还可以通过转到应用程序标签并点击应用程序来查看应用程序的详细信息，如下图所示：

在前面的截图中，你可以看到应用程序的状态，即已启动。你可以通过点击已启动旁边的重启按钮来重新启动应用程序。该应用程序使用的是 PHP 5.3 和 MySQL 5.1 卡带。要查看数据库密码，可以点击显示网页链接。要添加 phpMyAdmin 4.0 MySQL Web 客户端，请点击添加 phpMyAdmin 4.0网页链接。接下来，点击添加卡带按钮来添加 phpMyAdmin 4.0 卡带。

该卡带将可通过https://blog-{domain-name}.rhcloud.com/phpmyadmin/访问。phpMyAdmin 的凭据与数据库凭据相同。

另见

使用 Web 控制台上传 SSH 密钥 这篇教程
将应用程序克隆到本地机器 这篇教程
部署你的第一次更改 这篇教程

使用 Web 控制台上传 SSH 密钥

安全外壳协议（SSH）是一种网络协议，它保证了两台通过不安全网络连接的计算机之间的强大身份验证、数据加密和数据完整性。它采用客户端-服务器架构，并透明地加密客户端和服务器之间的数据。SSH 客户端通过加密的网络连接与 SSH 服务器通信。市面上有许多免费和商业产品实现了 SSH 协议。SSH 有多种身份验证机制，其中 OpenShift 使用的是公钥-私钥对认证机制。其他 SSH 认证方法，如密码认证和基于主机的认证，不在本书的范围内。

在此配方中，你将学习如何创建公私密钥对，并将公钥上传到你的 OpenShift 账户。OpenShift 使用 SSH 用于以下目的：

提供你机器与应用设备之间的安全加密连接
允许远程访问你的应用设备
使用你的应用 Git 仓库并将代码部署到 OpenShift
端口转发，允许用户从自己的机器连接到 OpenShift 服务，如数据库等

准备工作

为了完成此配方，你需要在机器上安装 OpenSSH SSH 连接工具。这些工具在大多数 Linux 安装、Macintosh OS X 和几乎所有 Unix 衍生操作系统中都很常见。微软 Windows 也有许多免费的和商业的 SSH 客户端，具体可以参考www.openssh.com/windows.html。此外，如果你在 Windows 机器上使用 PuTTY，可以参考www.openshift.com/developers/install-and-setup-putty-ssh-client-for-windows上的官方文档。

为了验证是否安装了 OpenSSH 客户端工具，运行以下命令：

$ ssh -V
OpenSSH_6.2p2, OpenSSL 1.0.1e-fips 11 Feb 2013

注意

前述命令的输出将取决于你的操作系统和你机器上安装的 OpenSSH 版本。如果出现ssh: command not found，则表示工具没有安装在你的机器上。

此配方将使用前述配方中创建的 WordPress 应用程序。

如何操作…

执行以下步骤：

运行ssh-keygen命令生成一对新的 SSH 密钥。ssh-keygen命令是 OpenSSH 安装的 SSH 工具之一。该命令将在用户的主目录下的.ssh文件夹中生成一个密钥对：
```
$ ssh-keygen -t rsa -b 2048 -C 'SSH keys to connect with OpenShift'
```
访问openshift.redhat.com/app/console/settings的设置网页，并粘贴公钥内容。公钥是扩展名为.pub的密钥。粘贴公钥内容后，点击保存按钮。
访问openshift.redhat.com/app/console/applications的应用程序网页，并点击应用程序查看详情，如下图所示：
接下来，通过点击想要登录到你的应用程序吗？来查看应用程序的 SSH 详情，如下图所示：
复制以下截图所示的应用程序 SSH 信息：
在你的本地机器上打开一个新的命令行终端，并运行以下命令。在这里，你将列出应用程序设备主文件夹中的目录。将 SSH 信息替换为你应用程序的 SSH 信息。
```
$ ssh 52b823b34382ec52670003f6@blog-osbook.rhcloud.com ls
app-deployments
app-root
git
mysql
php
phpmyadmin
```

它是如何工作的…

首先，让我们尝试理解你在上一部分中做了什么。在第一步中，你创建了一对新的 SSH 密钥。ssh-keygen 工具可以使用多个选项。以下是使用的三个选项之一：

-t 选项用于指定密钥的类型。可以选择 RSA 或 DSA 类型，在本例中使用的是 RSA 密钥类型。请注意，OpenShift 支持 RSA 和 DSA 两种密钥类型。
-b 选项用于指定密钥的位数。对于 RSA 密钥，最小大小为 768 位，默认大小为 2048 位。通常，2048 位被认为足够。
-C 选项用于提供注释，这对于标识密钥非常有用。该注释会附加到公钥中。

ssh-keygen 命令会提示用户回答几个问题，如下所示：

$ ssh-keygen -t rsa -b 2048 -C 'SSH keys to connect with OpenShift'
Generating public/private rsa key pair.
Enter file in which to save the key (/home/vagrant/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/vagrant/.ssh/id_rsa.
Your public key has been saved in /home/vagrant/.ssh/id_rsa.pub.
The key fingerprint is:
ad:59:8a:02:e6:94:35:92:a3:b9:94:93:c8:9a:30:47 SSH keys to connect with OpenShift
The key's randomart image is:
+--[ RSA 2048]----+
|                 |
|   .             |
|  E o            |
|o+o= .   .       |
|***     S o      |
|+O..   . =       |
|+ . . . +        |
|     .           |
|                 |
+-----------------+

首先，这个命令会要求用户提供 SSH 密钥文件名及其位置。RSA 密钥的默认文件名为 id_rsa（私钥）和 id_rsa.pub（公钥）。默认存储这些密钥的位置是用户 home 目录下的 .ssh 文件夹。

其次，它要求用户提供一个密码短语。如果不想使用密码短语，只需按两次 Enter 键。密码短语用于保护私钥。如果输入了密码短语，每次执行需要 SSH 的操作时，都将提示输入密码短语。在下一篇教程中，你将学习如何在不每次输入密码短语的情况下使用它。

当你运行任何 SSH 客户端（如 ssh）连接到 SSH 服务器时，客户端使用私钥来证明你的身份，而服务器使用公钥进行认证。如果认证成功，连接将继续进行。否则，你将收到错误消息。

在第二步中，你将公钥上传到 OpenShift 账户。OpenShift 会将公钥复制到应用程序装备上的授权文件 ~/.ssh/authorized_keys 中。之后，当 SSH 客户端请求连接到应用程序装备时，应用程序装备上运行的 SSH 服务器会查阅 authorized_keys 文件以查找匹配的公钥。

从第 3 步到第 5 步，你学习了如何使用 Web 控制台查找应用程序的 SSH 信息。在第 6 步，你通过在应用程序装备上执行 ls 命令来测试 SSH 连接。第一次连接到 SSH 服务器时，系统会询问是否要连接到该服务器。这是因为客户端不认识该服务器。SSH 客户端会查阅 ~/.ssh/known_hosts 文件以获取服务器信息。如果该文件中没有条目，它会要求确认，如下所示：

$ ssh 52b823b34382ec52670003f6@blog-osbook.rhcloud.com ls

The authenticity of host 'blog-osbook.rhcloud.com (54.221.64.115)' can't be established.
RSA key fingerprint is cf:ee:77:cb:0e:fc:02:d7:72:7e:ae:80:c0:90:88:a7.
Are you sure you want to continue connecting (yes/no)? yes

Warning: Permanently added 'blog-osbook.rhcloud.com,54.221.64.115' (RSA) to the list of known hosts.

app-deployments
app-root
git
mysql
php
phpmyadmin

在输入 yes 后，一个新条目将添加到 ~/.ssh/known_hosts 文件中。known_hosts 文件在 ~/.ssh/known_hosts 中充当数据库，客户端会在每次请求时检查此文件中的服务器条目。

注意

OpenShift 的 rhc 命令行客户端也提供了多种命令来操作 SSH 密钥。一旦安装了 rhc 客户端，你可以运行 rhc sshkey 命令查看所有支持的操作。

还有更多…

你可以选择为 SSH 密钥对使用其他名称或位置。你可以使用 ssh-keygen 工具创建另一个 SSH 密钥。这次，将密钥命名为 openshift_key：

$ ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/home/vagrant/.ssh/id_rsa): /home/vagrant/.ssh/openshift_key

访问 OpenShift 账户设置网页 openshift.redhat.com/app/console/settings，并删除现有的密钥，如下图所示：

现在，按照之前的讨论，将 openshift_key.pub SSH 密钥上传到 OpenShift 账户。

再次运行 ssh 命令。这次你会遇到一个错误，因为 SSH 客户端使用默认密钥与 SSH 服务器连接。默认密钥名称为 id_rsa。现在，让我们尝试在应用 gear 上运行 ls 命令，以确认是否遇到 Permission denied 错误：

$ ssh 52b823b34382ec52670003f6@blog-osbook.rhcloud.com ls
Permission denied (publickey,gssapi-keyex,gssapi-with-mic).

提示

若要获取调试信息，请使用以下命令：

ssh -v 52b823b34382ec52670003f6@blog-osbook.rhcloud.com ls

若要获取更多调试信息，请使用以下命令：

ssh -v -v -v 52b823b34382ec52670003f6@blog-osbook.rhcloud.com ls

上述命令中的 –v 选项数量定义了输出的详细程度。

若要连接应用 gear，必须使用 openshift_key 进行连接。要使用其他密钥，请运行以下命令：

$ ssh -i /home/vagrant/.ssh/openshift_key 52b823b34382ec52670003f6@blog-osbook.rhcloud.com ls

-i 选项用于告诉 SSH 客户端选择不同的 SSH 密钥。

另见

使用 SSH 密钥密码短语 配方

使用 SSH 密钥密码短语

在 通过网页控制台上传 SSH 密钥 配方中，你学会了如何创建一个新的 SSH 密钥对并将其上传到 OpenShift 账户。此 SSH 密钥对是使用空密码短语创建的。密码短语是用来保护私钥的密码。空密码短语避免了每次使用密钥时都需要重新输入密码，但可能会带来一些安全隐患。本配方将引导你完成保护 SSH 密钥的过程，同时避免每次使用密钥时都需要重新输入密码短语。

准备工作

要执行本配方，您需要在计算机上安装 OpenSSH SSH 连接工具。

为确保已安装 OpenSSH 客户端工具，请运行以下命令：

$ ssh -V
OpenSSH_6.2p2, OpenSSL 1.0.1e-fips 11 Feb 2013

上述命令的输出将取决于你计算机上安装的操作系统和 OpenSSH 版本。如果出现 ssh: command not found，说明你的计算机上未安装 OpenSSH 工具。

本配方将使用在 通过网页控制台上传 SSH 密钥 配方中创建的 WordPress 应用。

如何操作…

执行以下步骤以使用 SSH 密钥密码短语：

密码短语可以在创建密钥时添加，也可以添加到现有密钥中，而无需重新生成新的密钥对。由于你已经在使用 web 控制台上传 SSH 密钥的教程中创建了密钥对，我们将重用这个密钥对。你将使用ssh-keygen将密钥对添加到现有密钥中：

$ ssh-keygen -p
Enter file in which the key is (/home/vagrant/.ssh/id_rsa):
Key has comment '/home/vagrant/.ssh/id_rsa'
Enter new passphrase (empty for no passphrase): <Enter passphrase>
Enter same passphrase again: <Enter passphrase again>
Your identification has been saved with the new passphrase.

现在，如果你尝试 SSH 连接到应用程序设备，将会被要求输入密码短语。
接下来，运行 ssh-agent 命令。ssh-agent 命令是 OpenSSH 工具集的一部分，它用于安全地存储你的密码短语，以便你无需重新输入密码短语。你可以通过输入以下命令来运行 ssh-agent：
```
$ ssh-agent $SHELL
```

要添加密码短语，请运行 ssh-add 工具：

$ ssh-add
Enter passphrase for /home/vagrant/.ssh/id_rsa: <Enter passphrase>
Identity added: /home/vagrant/.ssh/id_rsa (/home/vagrant/.ssh/id_rsa)

连接到应用程序设备以查看 SSH 代理的运行。你会注意到此时不再要求输入密码短语：
```
$ ssh 52b823b34382ec52670003f6@blog-osbook.rhcloud.com ls
app-deployments
app-root
git
mysql
php
phpmyadmin
```
退出 shell 以结束 ssh-agent 会话。如果你现在尝试连接到应用程序设备，将会被要求输入密码短语：
```
$ ssh 52b823b34382ec52670003f6@blog-osbook.rhcloud.com ls
Enter passphrase for key '/home/vagrant/.ssh/id_rsa':
```

工作原理…

ssh-agent 工具将 SSH 密钥存储在内存中。它缓存私钥，并响应 SSH 客户端的认证查询。ssh-add 工具用于向 ssh-agent 中添加和移除密钥。在步骤 1 中，你已经将密码短语添加到了现有密钥中。默认情况下，它将使用 .ssh 文件夹中的默认密钥 id_rsa，但你也可以使用 -i 选项提供另一个 SSH 密钥文件。现在，SSH 连接到应用程序设备时，将会要求你输入密码短语：

$ ssh 52b823b34382ec52670003f6@blog-osbook.rhcloud.com ls
Enter passphrase for key '/home/vagrant/.ssh/id_rsa':

步骤 2 通过分叉现有 shell 启动代理。它设置了 SSH 代理所需的一些环境变量。接下来，在步骤 3 中，你将 SSH 密钥添加到代理中。它会要求输入密码短语以解密私钥。解密后，它将私钥添加到代理的缓存中。

最后，在步骤 4 中，你通过 ssh 客户端连接到应用程序设备。这次你不会被要求输入密码短语，因为代理已经缓存了私钥。

你可以终止代理或从 shell 中注销来结束会话。

另见

使用 web 控制台上传 SSH 密钥的教程

将应用程序克隆到本地机器

每个 OpenShift 应用程序都有一个私有 Git 仓库，用于存储应用程序的源代码。OpenShift 使用 Git 不仅作为版本控制系统，还利用 Git 的操作钩子来构建和部署应用程序。在本教程中，你将学习如何在本地机器上获取 OpenShift 应用程序的源代码。

准备工作

在进行此教程之前，你需要确保操作系统上已安装 Git。对于基于 Debian 的 Linux 发行版，你可以作为 root 用户通过 apt-get install git 安装 Git。如果你使用的是 Fedora 或其他基于 Red Hat 的系统，可以通过 yum install git-core 作为 root 用户安装 Git。Mac 和 Windows 用户可以从官方下载站点下载 Git 包：git-scm.com/downloads。

本步骤将使用在通过 Web 控制台创建 WordPress 应用程序步骤中创建的 WordPress 应用程序。

如何操作…

执行以下步骤以克隆仓库：

进入 Web 控制台的应用程序标签，在openshift.redhat.com/app/console/applications中点击应用程序查看其详细信息，如下截图所示：
复制应用程序详情网页上提到的 Git 仓库 URL，如下截图所示：
打开命令行终端，进入你机器上的一个方便位置，执行git clone命令。将仓库 URL 替换为你的应用程序 Git URL：
```
$ git clone ssh://52b823b34382ec52670003f6@blog-osbook.rhcloud.com/~/git/blog.git/
```

它是如何工作的…

第一步和第二步帮助我们找到了应用程序的 Git 仓库 URL。如前一部分所述，OpenShift 使用 Git 作为版本控制和源代码管理系统。每个应用程序都有一个私有 Git 仓库。Git 仓库包含所有保持和管理项目修订和历史所需的信息。OpenShift 使用 SSH 传输协议与 Git 仓库协作。为了在本地机器和应用程序设备之间创建安全的通信通道，Git 使用在通过 Web 控制台上传 SSH 密钥步骤中讨论的 SSH 密钥设置。除非你将他们的公钥添加到你的账户中，否则没人能够克隆你的应用程序仓库。

在第 3 步中，你通过clone命令克隆了应用程序的 Git 仓库。git clone命令基于原始应用程序仓库 URL 创建了一个新的 Git 仓库。Git 与其他版本控制系统的区别在于，Git 不仅克隆了工作副本，还克隆了仓库中所有文件的完整副本。clone命令将在你的本地文件系统上创建一个与应用程序同名的新目录。

还有更多…

你还可以通过git clone命令指定不同的文件夹名称。假设你想将应用程序克隆到myapp文件夹中。为此，请执行以下命令：

$ git clone ssh://52b823b34382ec52670003f6@blog-osbook.rhcloud.com/~/git/blog.git/ myapp

如果你想允许任何朋友或团队成员克隆你的仓库，只需将他们的公钥添加到你的账户中。请按照通过 Web 控制台上传 SSH 密钥的步骤上传公钥。我们将在第二章中详细讨论团队协作，管理域。

另见

部署你的第一次更改步骤

部署你的第一次更改

在将应用程序克隆到本地机器的步骤中，你学习了如何使用git clone命令克隆 OpenShift 应用程序的 Git 仓库。克隆仓库后的下一个逻辑步骤是做出更改，提交更改，最后部署它。在本节中，你将学习如何将源代码更改部署到 OpenShift 应用程序。

准备工作

要按照本节操作，你需要在本地机器上安装 Git。

如何操作…

执行以下步骤来部署你的第一次更改：

访问 OpenShift Web 控制台，转到 PHP 5.4 应用程序创建页面：openshift.redhat.com/app/console/application_type/cart!php-5.4。
输入应用程序的名称。我使用了myapp作为应用程序名称。
点击创建应用程序按钮来创建一个新应用程序。
通过按照将应用程序克隆到本地机器的步骤，克隆应用程序的 Git 仓库到你的本地机器。
打开应用程序源代码根目录中的index.php文件。然后在index.php中找到以下那行代码：
```
<h1>Welcome to your PHP application on OpenShift</h1>
```
用这个替换前面的那行代码：
```
<h1>Updated the application</h1>
```
使用 Git 将更改提交到本地仓库：
```
$ git commit -am 'modified index.php'
```
使用以下 Git 命令将更改推送到托管在 OpenShift 应用程序齿轮上的远程仓库：
```
$ git push origin master
```
在git push成功完成后，在你喜欢的浏览器中打开http://myapp-{domain-name}.rhcloud.com/应用程序。你将看到你第一次的更改。

它是如何工作的…

OpenShift 的部署过程基于 Git。从第 1 步到第 4 步，你使用 Web 控制台创建了一个 PHP 5.4 应用程序并将其克隆到本地机器。在第 5 步，你对index.php文件做了一个简单的更改，但这个更改尚未提交到本地仓库。Git 作为一个分布式版本控制系统，有本地仓库和远程仓库的概念。你可以继续在本地机器上进行工作（修改和提交），直到你准备好再将更改推送到远程 Git 仓库。

在第 6 步中，你使用git commit命令将更改提交到本地 Git 仓库。你使用了-a和-m选项。-a选项告诉git命令自动暂存已修改和已删除的文件，但不会处理新文件。要提交一个新文件，你必须先使用git add命令将文件暂存，然后再提交：

$ git add test.html
$ git commit -m 'new html file'

第 7 步将本地提交推送到远程仓库。当你克隆一个仓库时，克隆的仓库会通过名为origin的远程保持与其父仓库的连接。远程仓库是对另一个 Git 仓库的引用或标识。远程信息保存在.git文件夹下的一个名为config的配置文件中。你可以打开.git/config文件，查看origin远程信息，如下所示：

[remote 'origin']
  url = ssh://52bbf209e0b8cd707000018a@myapp-osbook.rhcloud.com/~/git/blog.git/
  fetch = +refs/heads/*:refs/remotes/origin/*

如前面的代码所示，远程由两个不同的部分组成。url 部分是以 URL 形式表示的远程仓库名称。fetch 部分指定了如何将引用从一个仓库的命名空间映射到另一个仓库的命名空间。

git push 命令的输出如下所示：

$ git push origin master
Counting objects: 7, done.
Compressing objects: 100% (4/4), done.
Writing objects: 100% (4/4), 404 bytes | 0 bytes/s, done.
Total 4 (delta 3), reused 0 (delta 0)
remote: Stopping PHP cartridge
remote: Waiting for stop to finish
remote: Stopping MySQL cartridge
remote: Stopping PHPMyAdmin cartridge
remote: Waiting for stop to finish
remote: Building git ref 'master', commit 3933f99
remote: Building PHP cartridge
remote: Preparing build for deployment
remote: Deployment id is b78e5efd
remote: Activating deployment
remote: Starting MySQL cartridge
remote: Starting PHPMyAdmin cartridge
remote: Database already configured.
remote: Starting PHP cartridge
remote: Result: success
remote: Activation status: success
remote: Deployment completed with status: success
To ssh://52bbf209e0b8cd707000018a@blog-osbook.rhcloud.com/~/git/blog.git/
 e83c2a7..3933f99  master -> master

这是这个过程的工作方式：

Git 会获取 master 分支的更改，对其进行压缩，并将所有缺失的对象从本地仓库传输到名为 origin 的远程仓库。
接下来，在应用程序 gear 上调用 pre-receive 动作钩子。Git 钩子是自定义脚本，Git 会在特定事件（如 push）发生时运行它们。你可以使用 bash、Perl、Python、Ruby 或任何你熟悉的语言编写脚本。pre-receive 钩子会接收所有（新的或旧的）需要更新的 refs 列表。应用程序 gear Git 仓库中的 pre-receive 动作钩子会停止 PHP 和其他 cartridge，检查部署的完整性，并配置部署元数据。
最后，在应用程序 gear 上调用 postreceive 动作钩子。它接收所有已更新的 refs 列表。应用程序 gear Git 仓库中的 postreceive 动作钩子将应用程序仓库归档，构建应用程序，启动 PHP 和其他 cartridge，然后最终部署应用程序。

还有更多…

你可以使用 git push 命令，而不是 git push origin master 命令。origin 部分是默认远程仓库，master 是默认分支，所以这两个部分不是必须的。

另见

将应用程序克隆到本地机器配方

检查应用程序的配额和限制

在这个配方中，你将学习如何检查应用程序的资源限制。

准备工作

要逐步完成这个配方，你需要在你的机器上安装 OpenSSH SSH 连接工具。这个配方将使用通过 Web 控制台创建 WordPress 应用程序配方中创建的 WordPress 应用程序。

如何操作…

要检查应用程序消耗的资源，请运行以下命令。在这里，你需要将 SSH URL 替换为你的应用程序 SSH URL。要查找你的应用程序的 SSH URL，请参考使用 Web 控制台上传 SSH 密钥配方。

$ ssh 52bbf209e0b8cd707000018a@blog-osbook.rhcloud.com quota -s

工作原理…

OpenShift 应用程序运行在资源有限的 gears 中。每个 gear 根据其大小有一定的资源。可以使用 quota -s 命令来检查应用程序消耗的资源以及施加在 gear 上的限制。

quota -s 命令的输出如下所示：

Disk quotas for user 52bbf209e0b8cd707000018a (uid 2187):
 Filesystem  blocks   quota   limit   grace   files   quota   limit   grace
/dev/mapper/EBSStore01-user_home01
 124M       0   1024M            2898       0   80000

第一列是启用了配额的文件系统名称。第二列显示当前用户使用的块数。第四列告诉我们存储限制。免费套餐中的 Gear 访问 1 GB 的磁盘存储空间。第六列显示应用程序创建的文件数量。第八列显示用户可以创建的最大文件数。Gear 最多可以创建 80,000 个文件。Gear 还限制了 RAM 内存。小型 Gear 具有 512 MB 的 RAM，中型 Gear 具有 1 GB 的 RAM，大型 Gear 具有 2 GB 的 RAM。中型和大型 Gear 仅在 Bronze 和 Silver 商业计划中提供。

还有更多内容……

您还可以通过运行 ***du*** 命令来查看 Gear 使用了多少磁盘空间：

$ ssh 52bbf209e0b8cd707000018a@blog-osbook.rhcloud.com 'du -sh *'

17M	app-deployments

安装 OpenShift rhc 命令行客户端

rhc 客户端是功能最强大、最丰富的命令行客户端工具，用户可以用它与 OpenShift 进行交互。它是使用 Ruby 编程语言构建的，并作为 Ruby gem 包装。rhc 的源代码可以在 GitHub 上找到：github.com/openshift/rhc。

准备工作

要安装 rhc，您需要确保您的机器上安装了 Ruby 1.8.7 或更高版本。您可以通过运行以下命令检查是否已安装 Ruby：

$ ruby --version
ruby 2.0.0p247 (2013-06-27 revision 41674) [x86_64-linux]

上述命令的输出将取决于您机器上安装的操作系统和 Ruby 版本。如果收到 ruby: command not found 的消息，说明您的机器上未安装 Ruby。请在您的操作系统上安装 Ruby。您可以从官方网站 www.ruby-lang.org/en/downloads/ 下载适用于您的操作系统的安装包。

如何操作……

打开一个新的命令行终端并运行以下命令：

$ gem install rhc

此命令将安装与 OpenShift 配合使用所需的 rhc gem。

工作原理……

OpenShift 将 rhc 命令行工具打包为 gem。Gem 是一段可重用的代码或命令行工具，帮助自动化任务。RubyGems 是 Ruby 编程语言的包管理器，它提供了分发 Ruby 程序和库的标准格式。该软件允许开发者在他们的机器上下载、安装和使用软件包。gem 命令使您能够使用 RubyGems。

当您运行 gem install 命令时，gem 命令行工具会从中央仓库获取包及其依赖项并安装它们。中央 gem 仓库可以通过 rubygems.org 访问。

命令成功执行后，您可以使用以下命令检查 rhc 的版本：

$ rhc --version
rhc 1.27.4

还有更多内容……

gem install 命令还会生成已安装包的文档。您可以使用 Ruby ri 命令行工具离线查看文档。例如，如果您想列出所有 ri 可以显示文档的类，请运行以下命令：

$ ri --list

此命令将列出所有类及其方法，你可以查看相关文档。要查看 RHC 类的 CLI 类方法的文档，请执行以下命令：

$ ri RHC::CLI

输出将是 CLI 方法的文档，如下所示：

= RHC::CLI
(from gem rhc-1.27.4)
------------------------------------------------------------------------------
Run and execute a command line session with the RHC tools.

You can invoke the CLI with:
 bundle exec ruby -e 'require 'rhc/cli'; RHC::CLI.start(ARGV);' -- <arguments>

你可以通过使用以下命令禁用文档生成：

$ gem install rhc --no-document

参见

使用 rhc 设置 OpenShift 账户 教程
更新 rhc 教程

使用 rhc 设置 OpenShift 账户

在安装 OpenShift rhc 命令行客户端这一教程中，你学习了如何安装rhc命令行客户端。安装完成后，你需要执行的第一步操作是设置 OpenShift 账户。在本教程中，你将学习如何使用rhc设置账户。

准备工作

完成本教程之前，你需要在你的机器上安装 rhc。有关安装说明，请参见安装 OpenShift rhc 命令行客户端教程。

如何操作…

要设置 OpenShift 账户，请打开命令行终端并运行以下命令：

$ rhc setup

它是如何工作的…

在你能够使用 rhc 客户端与 OpenShift 配合使用之前，你必须先设置账户。

setup命令执行以下操作：

它首先会要求你提供 OpenShift 凭证，以便认证到 openshift.redhat.com。
在成功认证后，rhc 会询问是否创建授权令牌。授权令牌使你无需在每次执行命令时输入密码即可访问 OpenShift 服务器。它将令牌存储在用户 home 目录下的 .openshift 文件夹中。默认情况下，令牌的有效期为 30 天，过期后需要重新认证。
接下来，setup命令将在用户的 home 目录下的 .openshift 文件夹中创建一个名为 express.conf 的文件。express.conf 文件存储了 rhc 所需的基本配置，例如 OpenShift 服务器的位置、你的 OpenShift 用户名，以及是否创建并使用授权令牌。
如果 ~/.ssh 文件夹中没有 SSH 密钥，则 rhc 的 setup 命令将使用 ssh-keygen 工具生成一个新的密钥对。
在生成新的 SSH 密钥对后，rhc会将公钥上传到 OpenShift 服务器。OpenShift 将公钥复制到应用程序硬件上的授权文件 authorized_keys 中，路径为 ~/.ssh/authorized_keys。在使用 Web 控制台上传 SSH 密钥这一教程中，你已经使用 Web 控制台上传了公钥。系统会提示你提供密钥名称，或者使用 setup 命令生成的默认名称。
接下来，rhc 会检查 Git 是否已安装。rhc setup 命令会对本地配置和凭据进行简单检查，以确认配置已完成。它还会运行一系列测试，检查 ssh 是否已正确配置，以及您的系统是否可以与 OpenShift 服务器通信。
最后，如果用户尚未创建域，rhc 会提示用户创建一个。在 使用 Web 控制台创建 OpenShift 域 配方中，您通过 Web 控制台创建了该域。

还有更多……

在使用 OpenShift 时，您可以随时运行 rhc setup 命令。每次运行 rhc setup 命令时，它将使用在 express.conf 文件中定义的配置属性。如果您想生成一个新的干净配置，可以使用 --clean 选项。这样会重新运行 setup 命令，忽略 express.conf 中存储的任何已保存的配置选项：

$ rhc setup --clean

另请参见

启用 rhc 命令行客户端的自动完成功能 配方
使用 rhc 查看帐户详细信息 配方
指定不同的 OpenShift 服务器主机名 配方

启用 rhc 命令行客户端的自动完成功能

rhc 命令行工具支持自动补全功能。这意味着 rhc 可以预测用户想要输入的命令，而用户无需完全输入。这对那些不熟悉 rhc 支持的所有命令的新用户非常有帮助。在本配方中，您将学习如何为 rhc 命令行客户端启用自动补全功能。

注意

自动完成功能不适用于 Windows Terminal。

准备工作

要按步骤操作此配方，您需要在计算机上安装 rhc。有关安装说明，请参阅 安装 OpenShift rhc 命令行客户端 配方。

如何操作……

要启用自动补全功能，请执行以下步骤：

再次运行 rhc setup 命令，并使用 autocomplete 选项：
```
$ rhc setup --autocomplete
```
上一步将生成一个名为 bash_autocomplete 的文件，位于 ~/.openshift 文件夹中。要启用自动补全，您必须将 ~/.openshift/bash_autocomplete 这一行添加到您用户主目录下的 .bashrc 或 .bash_profile 文件中。我在 Fedora 系统上的 .bashrc 文件如下所示：
```
# .bashrc
. ~/.openshift/bash_autocomplete
# Source global definitions
if [ -f /etc/bashrc ]; then
. /etc/bashrc
fi
# User specific aliases and functions
```
请注意，在 Mac OS X 上，您必须将 ~/.openshift/bash_autocomplete 添加到 ~/.bash_profile 文件中。在 Mac OS X 上，新打开的终端窗口和标签始终被视为登录 Shell，因此这是 OS X 用户必须执行的必要步骤。
重新加载或重新启动 Shell 以使这些更改生效。

工作原理……

你应该理解前面章节中你所做的操作。在步骤 1 中，你使用autocomplete选项运行了setup命令。这在~/.openshift文件夹中生成了一个名为bash_autocomplete的 bash 脚本。这个 bash 脚本定义了一个名为_rhc的自定义补全函数，用于rhc命令行客户端。当你在提示符下输入rhc并按下 Tab 键时，Bash 会执行这个函数，并显示可能的补全项。

在步骤 2 中，你通过将~/.openshift/bash_autocomplete添加到.bashrc脚本中来加载bash_autocomplete文件。这将确保在每个 shell 中都能使用自动补全功能。

最后，在步骤 3 中，你重新启动了 shell 以加载_rhc函数。现在，如果你输入rhc并按下Tab键，它会显示所有rhc命令：

$ rhc
account                   app-tidy                  deployment-list  member-list // removed all commands for brevity

还有更多…

大多数rhc命令都有可用的选项，你可以提供这些选项。要查看命令的所有选项，可以输入--并按Tab键。例如，要查看rhc setup命令的所有选项，输入rhc setup --并按Tab键：

$ rhc setup --
--autocomplete     --clean            --create-token     --no-create-token  --server

另请参见

使用 rhc 设置 OpenShift 账户配方

使用 rhc 查看账户详情

在本配方中，你将学习如何使用rhc查看账户详情。

准备工作

要完成本配方，你需要在你的机器上安装rhc。请参考安装 OpenShift rhc 命令行客户端配方获取安装说明。

如何操作…

要查看账户详情，请运行以下命令rhc account：

$ rhc account

这就是查看账户详情所需做的全部操作。

如何工作…

rhc account命令显示当前登录用户的详细信息。当你运行该命令时，它会使用在rhc setup过程中生成的认证令牌，向 OpenShift REST API 发出 REST 调用。REST API 返回一个 JSON 响应，rhc会以易于阅读的格式显示出来：

$ rhc account
Login openshift.cookbook@gmail.com on openshift.redhat.com
----------------------------------------------------------
 ID:                 52b8112ae0b8cdc308000018
 Plan:               Free
 Gears Used:         0
 Gears Allowed:      3
 Domains Allowed:    1
 Allowed Gear Sizes: small
 SSL Certificates:   no

账户详情包括当前登录用户信息、连接的 OpenShift 服务器、OpenShift 用户 ID、使用的 OpenShift 计划、使用的和允许的 gear 数量及其大小、允许的域名数量以及是否可以使用 SSL 证书等信息。

你还可以通过访问openshift.redhat.com/app/account在 Web 控制台中查看账户详情。

还有更多…

你还可以通过传递-l或--rhlogin选项来查看其他 OpenShift 账户的详情。-l或--rhlogin选项是每个命令都可以使用的全局选项。当你使用-l或--rhlogin时，会强制rhc客户端使用用户指定的登录信息：

$ rhc account --rhlogin user@example.com

你可以通过使用rhc account-logout命令退出当前会话，这将结束用户的当前会话并删除~/.openshift文件夹中的授权令牌文件：

$ rhc account-logout

你也可以使用rhc logout作为rhc account-logout的简短替代命令。

另请参见

使用 rhc 设置 OpenShift 账户食谱

指定一个不同的 OpenShift 服务器主机名

本食谱介绍了如何配置一个不同的 OpenShift 服务器主机名。默认情况下，当你使用rhc setup命令设置 OpenShift 账户时，rhc会被配置为与公开的 OpenShift PaaS（托管在openshift.redhat.com上）一起使用。然而，也可以使用一个不同的 OpenShift 安装版本，这可以是 OpenShift Enterprise 或 OpenShift Origin 的安装。

准备工作

要按照本食谱操作，你需要在机器上安装rhc。请参考安装 OpenShift rhc 命令行客户端食谱中的说明。

如何操作…

打开命令行终端，运行以下命令来使用不同的 OpenShift 服务器主机名：

$ rhc setup --server <My OpenShift Installation Hostname>

将<My OpenShift Installation Hostname>替换为 OpenShift 服务器的主机名。

它是如何工作的…

rhc setup命令有一个选项--server，允许用户指定服务器的主机名。当你运行带有新服务器位置的rhc setup命令时，setup命令将执行所有必要的操作来配置你的 OpenShift 账户，以便与新服务器一起使用。setup命令将用新的服务器主机名覆盖~/.openshift中的express.conf文件。rhc客户端将被配置为与新的 OpenShift 服务器一起使用。

还有更多…

你还可以通过直接编辑~/.openshift/express.conf中的express.conf文件来配置服务器。libra_server属性如下：

# The OpenShift server to connect to
libra_server=openshift.redhat.com

将上面的代码更改为新的服务器主机名：

# The OpenShift server to connect to
libra_server=<Your OpenShift Installation>

另请参见

使用 rhc 设置 OpenShift 账户食谱
使用 rhc 查看账户详情食谱

更新 rhc

OpenShift 命令行工具rhc是与 OpenShift 交互的最强大、最流行的方式。在本食谱中，你将学习如何将rhc更新到最新版本。OpenShift Online 有一个三周的发布周期，通常情况下，rhc客户端工具也会被更新，以支持新特性或修复漏洞。因此，始终使用最新版本的rhc会有所帮助。

准备工作

为了准备本食谱，你需要一个已经安装好的rhc。不需要其他先决条件。

如何操作…

要更新rhc gem，运行gem update命令：

$ gem update rhc

这就是你需要做的，来将rhc命令行更新到最新版本。

它是如何工作的…

rhc是一个 Ruby gem，而RubyGems是一个包管理器，类似于其他许多包管理器。它使用一个中央仓库来托管可安装的软件包。当你运行gem update命令时，这个命令行工具会从中央仓库获取最新的软件包并进行安装。

还有更多…

当你开始使用rhc时，你很快会在你的机器上安装多个版本的rhc gem。你可以使用cleanup命令卸载所有先前的版本。该命令将卸载本地仓库中已安装的旧版本 gem：

$ gem cleanup rhc

另请参阅

安装 OpenShift rhc 命令行客户端 配方

第二章：管理域

本章介绍了一些示例，展示了如何开始创建和管理域。你还将学习到域如何帮助你作为团队成员合作并共同完成项目。本章的具体示例包括：

使用 rhc 创建一个域
使用 rhc 重命名域
使用 rhc 查看域的详细信息
使用 rhc 将查看成员添加到域中
使用 rhc 将编辑成员添加到域中
使用 rhc 将管理员成员添加到域中
使用 rhc 查看域中的所有成员
使用 rhc 从域中移除成员
使用 rhc 限制域的 gear 大小
使用 rhc 离开一个域
使用 rhc 删除域

介绍

域代表每个用户的唯一名称，每个用户的应用程序必须存在于此域中。OpenShift 用户在拥有有效域之前无法创建应用程序。域名成为应用程序 URL 的一部分。例如，如果你的域名是foo，而你的应用程序名是bar，则应用程序的 URL 将是http://bar-foo.rhcloud.com。每个 OpenShift 账户必须至少与一个域关联。OpenShift Online 的免费套餐不允许用户创建多个域，但付费套餐允许创建多个域。域使用户可以为其应用程序选择任何有效的名称。它们还允许两个或更多用户为他们的应用程序使用相同的名称。例如，用户 A 可以在域foo中拥有名为bar的应用程序，同样，用户 B 也可以在域test中拥有名为bar的应用程序。一旦用户拥有有效的域，他们就可以为应用程序使用任何有效的名称。

团队协作是现代软件开发中的核心特性之一。无论你是在做开源项目还是企业项目，你都需要与他人合作。一个团队可能会共同努力，帮助软件项目成功。域使得团队协作成为可能，因为你可以将其他用户添加到你的域中，赋予他们与应用程序协作的权限。这让不同的用户在项目上协作变得非常容易。你可以将用户添加到你的域中，权限可以是查看者、编辑者或管理员。本章的第 4 到第 6 个示例将详细介绍这些内容。

域还帮助我们在应用程序中融入环境的概念。你可以为不同的环境创建不同的域。一个可以用作开发环境，另一个作为质量保证环境，第三个则用于生产环境。这让你可以为不同的人分配不同的访问权限。你的开发人员可以访问开发和质量保证域，但无法访问生产域。

使用 rhc 创建一个域

在第一章中的 使用 Web 控制台创建 OpenShift 域名 配方里，你学习了如何使用 Web 控制台创建域名。在本配方中，你将学习如何使用 rhc 命令行创建域名。

准备工作

要完成这个配方，你需要在机器上安装 rhc。请参阅第一章中的 安装 OpenShift rhc 命令行客户端 配方，开始使用 OpenShift，获取安装说明。如果你使用的是 OpenShift 的免费计划，你必须先删除在第一章中 使用 Web 控制台创建 OpenShift 域名 配方里创建的域名，然后才能继续本配方。这是因为在 OpenShift 的免费计划中，你不能拥有多个域名。要删除一个域名，请运行如下命令。这个命令在本章的 使用 rhc 删除域名 配方中有详细说明：

$ rhc delete-domain <domain_name> --force

如何操作…

要创建域名，请打开一个新的命令行终端，并运行以下命令。请提供一个唯一的域名。

$ rhc create-domain --namespace <unique_domain_ame>

注意

如果你在运行此命令时收到 You may not have more than 1 domain 错误，删除与你账户关联的现有域名。在免费套餐中，你不能创建多个域名。

它是如何工作的…

你可以使用 rhc domain-create 或 rhc create-domain 命令来创建一个新的域名。创建域名时唯一需要的参数是一个唯一的字母数字名称。请注意，一个域名最多只能包含 16 个字母数字字符，且不能包含空格或符号。

rhc create-domain 命令的输出如下所示：

$ rhc create-domain --namespace osbook
Creating domain 'osbook' ... done
You may now create an application using the 'rhc create-app' command

你可以通过输入以下命令来避免使用 --namespace 选项。rhc 命令行客户端非常智能，会自动识别你仅提供了必要的参数：

$ rhc domain-create osbook

还有更多…

所有 OpenShift 命令都有帮助文档。要了解 rhc create-domain 命令的使用方法以及其所有可用选项，你可以使用 -h 或 --help 选项。我们将在后续的配方中详细讲解其他选项。

$ rhc create-domain --help
Usage: rhc domain-create <namespace>

另请参见

第一章中的 使用 Web 控制台创建 OpenShift 域名 配方，开始使用 OpenShift
使用 rhc 重命名域名 配方
使用 rhc 查看域名详情 配方
使用 rhc 删除域名 配方

使用 rhc 重命名域名

在创建完域名后，你可能需要重命名它。假设你想重命名现有的名称，以反映其环境。例如，你可以将 osbook 域名重命名为 devosbook，以便表示 devosbook 为你的开发环境。

准备工作

要完成此教程，你需要在你的机器上安装 rhc。请参考第一章中的安装 OpenShift rhc 命令行客户端教程，了解详细步骤，开始使用 OpenShift。

如何操作…

要重命名一个域，打开一个新的命令行终端，并运行以下命令。你需要提供一个唯一的新域名：

$ rhc rename-domain <old_domain_name> <new_domain_name>

它是如何工作的…

要重命名域，你必须首先确保没有与该域关联的应用程序。如果域上有任何应用程序，你必须先删除它们。要了解如何删除应用程序，请参考第三章中的删除应用程序教程，创建和管理应用程序。rename-domain命令首先删除旧域，然后使用新域名创建一个新域。要将osbook域重命名为devosbook，你需要运行以下命令：

$ rhc domain-rename osbook devosbook
Renaming domain 'osbook' to 'devosbook' ... done

另见

第一章中的使用 Web 控制台创建 OpenShift 域教程，开始使用 OpenShift
使用 rhc 重命名域教程
使用 rhc 查看域详细信息教程
使用 rhc 删除域教程

使用 rhc 查看域详细信息

在本教程中，你将学习如何查看与域相关的详细信息。

准备工作

要完成此教程，你需要在你的机器上安装 rhc。请参考第一章中的安装 OpenShift rhc 命令行客户端教程，了解详细步骤，开始使用 OpenShift。

此外，你还需要一个有效的域与您的账户相关联。请参考本章中的使用 rhc 创建域教程，了解如何创建一个新的域。

如何操作...

要查看域的详细信息，打开一个新的命令行终端，并运行以下命令：

$ rhc show-domain --namespace <your domain name>

它是如何工作的...

rhc show-domain命令返回一个域及其应用程序的详细信息。命令的输出如下所示。详细信息包括域名、所有者的电子邮件 ID、其他域成员以及该域内所有应用程序的信息：

$ rhc show-domain --namespace devosbook
Domain devosbook (owned by openshift.cookbook@gmail.com)
--------------------------------------------------------
Created: 9:49 AM
Allowed Gear Sizes: small
Members: shekhar.redhat@gmail.com (edit)

blog @ http://blog-devosbook.rhcloud.com/ (uuid: 52d56620e0b8cd9911000166)
--------------------------------------------------------------------------
Domain: devosbook
Created: 11:30 AM
Gears: 1 (defaults to small)
Git URL: ssh://52d56620e0b8cd9911000166@blog-devosbook.rhcloud.com/~/git/blog.git/
Initial Git URL: git://github.com/openshift/wordpress-example.git
SSH: 52d56620e0b8cd9911000166@blog-devosbook.rhcloud.com
Deployment: auto (on git push)

php-5.3 (PHP 5.3)
-----------------
Gears: Located with mysql-5.1

mysql-5.1 (MySQL 5.1)
---------------------
Gears: Located with php-5.3
Connection URL: mysql://$OPENSHIFT_MYSQL_DB_HOST:$OPENSHIFT_MYSQL_DB_PORT/
Database Name: blog
Password: teic7xz7JUFv
Username: adminiabcAWU

You have 1 application in your domain.

--namespace 选项是可选的。如果您不指定 --namespace 选项，OpenShift 将首先尝试从当前目录中的 Git 仓库配置文件中查找域名。它将您运行命令的目录视为 OpenShift 应用程序的 Git 仓库。它使用 git config --get rhc.domain-name 命令来查找域名。由于我们没有在 OpenShift 应用程序的 Git 仓库中运行命令，OpenShift 将发出一个 GET REST API 请求来获取与用户相关的所有域。用户的详细信息和授权令牌信息将从 ~/.openshift 文件夹中获取。在找到与用户相关的所有域后，将进行一次 GET REST API 调用，以获取每个域的详细信息。最后，结果将显示给用户。

还有更多…

您还可以通过运行 rhc list-domain 命令查看您有权限访问的所有域：

$ rhc list-domain
Domain devosbook (owned by openshift.cookbook@gmail.com)
--------------------------------------------------------
Created: 9:49 AM
Allowed Gear Sizes: small
Members: shekhar.redhat@gmail.com (edit)

Domain ndtv123 (owned by shekhar.redhat@gmail.com)
--------------------------------------------------
Created: 12:08 PM
Allowed Gear Sizes: small
Members: openshift.cookbook@gmail.com (view)

如您所见，openshift.cookbook@gmail.com 用户可以访问两个域。openshift.cookbook@gmail.com 用户拥有 devosbook 域，但它是 ndtv123 域的唯一成员。

如果用户只想查看自己的域，他/她可以使用 --mine 参数，如以下命令行输出所示。要查看命令的所有可用选项，可以传递 --help 选项：

$ rhc list-domain --mine
Domain devosbook (owned by openshift.cookbook@gmail.com)
--------------------------------------------------------
Created: 9:49 AM
Allowed Gear Sizes: small
Members: shekhar.redhat@gmail.com (edit)

You have access to 1 domain.

另请参见

使用 rhc 创建域 配方
使用 rhc 查看域详细信息 配方
使用 rhc 删除域 配方

使用 rhc 向域添加查看者成员

假设您是组织的系统管理员，您的工作是确保所有生产应用程序都能顺利运行。理想情况下，您不希望组织中的所有开发人员都能访问生产环境。让每个人都能访问生产环境，就是在等待不可避免的事情发生。您应该记住的是，您可以为不同的环境创建不同的域。与生产部署相关的域将由系统管理员而非开发人员进行控制。OpenShift 允许您为不同的人群设置不同的访问级别。您和其他系统管理员可以享有生产域的管理员权限，而开发人员则只能在需要时享有查看者权限。开发人员将以只读模式被添加到生产域。他们可以查看有关该域及其应用程序的信息，但无法进行任何更改。他们也不能使用 Git 克隆源代码或部署更改。查看者也不允许通过 SSH 访问应用程序的运行环境。

准备就绪

要完成此配方，您需要在您的机器上安装 rhc。请参阅第一章中的安装 OpenShift rhc 命令行客户端配方，开始使用 OpenShift，以获取安装说明。

您需要两个 OpenShift 帐户来完成此步骤。有关 OpenShift 帐户注册的说明，请参考第一章中的创建 OpenShift Online 帐户一节，开始使用 OpenShift。

如何操作…

假设我们有两个 OpenShift 用户，openshift.cookbook@gmail.com和openshift.cookbook.test@gmail.com。您可能想要将openshift.cookbook.test@gmail.com添加为openshift.cookbook@gmail.com的prodosbook域的查看者。prodosbook域对应于您应用程序的生产环境。为此，请执行以下命令：

$ rhc add-member openshift.cookbook.test@gmail.com --namespace prodosbook --role view

如何操作…

add-member命令允许您向您的域中添加成员。用户可以被添加到三种角色中的一种：view（查看）、edit（编辑）或admin（管理员）。在本步骤中，我们可能希望将openshift.cookbook.test@gmail.com添加为查看者，因此我们使用--role选项为该用户分配查看角色。

rhc add-member命令的语法如下所示：

$ rhc add-member <login> --namespace <namespace> --role <role>

命令的解析如下：

login：这是您要添加为成员的 OpenShift 帐户的电子邮件 ID 或简称。
namespace：这是您希望添加成员的域名。
role：指的是您希望赋予成员的访问级别。

您可以通过查看域详细信息来查看已添加的用户：

$ rhc show-domain

Domain prodosbook (owned by openshift.cookbook@gmail.com)
-----------------------------------------------------
Created: Jan 14 9:49 AM
Allowed Gear Sizes: small
Members: openshift.cookbook.test@gmail.com (view)

blog @ http://blog-prodosbook.rhcloud.com/ (uuid: 52d681815973ca43d600009a)
-----------------------------------------------------------------------
// app details .. removed for brevity
You have 1 application in your domain.

如果openshift.cookbook.test@gmail.com用户尝试将应用程序克隆到本地计算机，他们将收到如下所示的权限拒绝错误：

$ rhc git-clone blog -l openshift.cookbook.test@gmail.com
Cloning into 'blog'...
Permission denied (publickey,gssapi-keyex,gssapi-with-mic).
fatal: The remote end hung up unexpectedly
Unable to clone your repository. Called Git with: git clone
ssh://52d681815973ca43d600009a@blog-prodosbook.rhcloud.com/~/git/blog.git/ "blog"
You can also use the OpenShift account user id instead of the OpenShift login.
$ rhc add-member --ids 52d6784e5004462a80000235 --namespace prodosbook --role view
To get the id for an OpenShift account, you can use the rhc account command.
$ rhc account
Login openshift.cookbook.test@gmail.com on openshift.redhat.com
---------------------------------------------------------------
ID: 52d6784e5004462a80000235
Plan: Free
Gears Used: 0
Gears Allowed: 3
Domains Allowed: 1
Allowed Gear Sizes: small
SSL Certificates: no

您还可以一次性将多个成员添加到您的域中，如下所示：

$ rhc add-member openshift.cookbook.test@gmail.com shekhar.redhat@gmail.com --namespace prodosbook --role view

这同样适用于 OpenShift 帐户 ID，只需输入以下命令：

$ rhc member-add --ids 52d6784e5004462a80000235 52d6784e5004462a80000236 --namespace prodosbook --role view

还有更多内容…

OpenShift 网页控制台也允许用户添加成员。您可以通过访问openshift.redhat.com/app/console/domain/{domain-name}并将{domain-name}替换为您的帐户域名来进行此操作。然后，点击添加成员…的网页链接：

在点击保存之前，输入用户登录信息以及您想分配给用户的角色：

参见

使用 rhc 向域中添加编辑成员的步骤
使用 rhc 向域中添加管理员成员的步骤
使用 rhc 查看域中所有成员的步骤

使用 rhc 向域中添加编辑成员

假设您是一个使用 OpenShift 进行开发的软件开发团队的领导者。在开发过程中，您希望团队中的所有开发人员都能够创建、删除、推送或甚至 SSH 到应用程序的 gear 中。然而，您不希望用户重命名或删除域，因为这可能会影响团队中其他开发人员或其他团队。另一个不希望发生的情况是，允许开发人员更改 gear 的大小。您可以限制开发域仅使用小型 gear 来节省成本。在这种情况下，您将给予开发人员一个编辑者角色，使他们可以自由地操作应用程序，但不能操作域。

准备工作

要完成此食谱，您需要在计算机上安装 rhc。请参考第一章中的安装 OpenShift rhc 命令行客户端食谱，了解相关的安装说明。

您将需要两个 OpenShift 账户来完成此食谱。请参考第一章中的创建 OpenShift 在线账户食谱，了解 OpenShift 账户注册的详细说明。

如何操作……

要将openshift.cookbook.test@gmail.com用户作为编辑者添加到openshift.cookbook@gmail.com的devosbook域中，请运行以下命令：

$ rhc add-member openshift.cookbook.test@gmail.com --namespace devosbook --role edit

工作原理……

编辑角色允许用户对域执行以下操作：

用户可以在域下创建应用程序
用户可以删除域下的应用程序
用户可以查看应用程序的日志
用户可以执行其他与应用程序相关的操作，例如启动、停止和重启
用户可以使用 Git 推送源代码
用户可以使用 SSH 进入应用程序 gear

当您使用编辑角色运行rhc add-member命令时，OpenShift 将首先为域添加一个具有编辑角色的新成员，然后将用户的公钥 SSH 密钥复制到 OpenShift gear 的~/.ssh/authorized_keys文件中。这样，编辑者可以执行与 SSH 相关的操作，如通过 Git 和 SSH 将代码部署到应用程序 gear 中。

要检查编辑者是否已成功添加，您可以查看域的详细信息：

$ rhc show-domain
Domain devosbook (owned by openshift.cookbook@gmail.com)
-----------------------------------------------------
Created: Jan 14 9:49 AM
Allowed Gear Sizes: small
Members: openshift.cookbook.test@gmail.com (edit)

还有更多……

您也可以使用 Web 控制台将编辑者添加到您的应用程序中。只需按照本章中使用 rhc 将查看者成员添加到域中食谱中提到的步骤操作。

另请参见

使用 rhc 将查看者成员添加到域中的食谱
使用 rhc 将管理员成员添加到域中食谱
使用 rhc 查看域中所有成员食谱

使用 rhc 将管理员成员添加到域中

假设一个新的系统管理员加入您的团队。由于新的系统管理员也负责确保您的生产应用程序运行顺利，因此您希望将该新系统管理员添加为管理员。您可以通过赋予新用户管理员角色来实现这一点。

准备工作

要完成这个配方，你需要在你的机器上安装 rhc。请参阅第一章中的安装 OpenShift rhc 命令行客户端配方，获取安装说明。

你需要两个 OpenShift 账户才能执行本配方。请参阅第一章中的创建 OpenShift Online 账户配方，获取 OpenShift 账户注册的说明。

如何操作…

要将openshift.cookbook.test@gmail.com用户作为管理员添加到<openshift.cookbook@gmail.com>域的prodosbook中，请运行以下命令：

$ rhc add-member openshift.cookbook.test@gmail.com --namespace osbook --role admin

它是如何工作的…

管理员角色允许用户在域上执行以下操作：

编辑者可以执行的所有操作，如与应用程序相关的操作
对域执行操作，如将成员添加到域中

当你使用管理员角色运行rhc add-member命令时，OpenShift 将以管理员角色将新成员添加到域，并将公钥复制到 OpenShift gear 的~/.ssh/authorized_keys文件中。这样，编辑者就可以执行与 SSH 相关的操作。

要检查管理员是否已成功添加，可以通过插入以下命令查看域的详细信息：

$ rhc domain-show

Domain prodosbook (owned by openshift.cookbook@gmail.com)
-----------------------------------------------------
Created: Jan 14 9:49 AM
Allowed Gear Sizes: small
Members: openshift.cookbook+test@gmail.com (admin)

还有更多…

你也可以使用 Web 控制台将编辑器添加到你的应用程序中。只需按照本章中使用 rhc 将查看者成员添加到域配方中提到的步骤操作。

另请参见

使用 rhc 将查看者成员添加到域配方
使用 rhc 将管理员成员添加到域配方
使用 rhc 查看域中的所有成员配方

使用 rhc 查看域中的所有成员

可能会有一种情况，你想查看域中的所有成员。如果是这样，你应该遵循这个配方。

准备工作

要完成这个配方，你需要在你的机器上安装 rhc。请参阅第一章中的安装 OpenShift rhc 命令行客户端配方，获取安装说明。

你需要两个 OpenShift 账户才能执行本配方。请参阅第一章中的创建 OpenShift Online 账户配方，获取 OpenShift 账户注册的说明。

如何操作…

要查看添加到osbook域的所有成员，请运行以下命令：

$ rhc list-member --namespace osbook

它是如何工作的…

rhc list-member命令的结果如下所示：

Login Role
--------------------------------- -------------
openshift.cookbook@gmail.com admin (owner)
openshift.cookbook.test@gmail.com admin

rhc list-member命令发起一个GET请求，获取osbook域的所有信息。然后，rhc 客户端解析JSON响应并将相关信息展示给用户。

还有更多…

你也可以使用快捷命令来获取域中的所有成员：

$ rhc members --namespace osbook

另见

使用 rhc 向域添加查看者成员 配方
使用 rhc 向域添加管理员成员 配方
使用 rhc 查看域中的所有成员 配方

使用 rhc 从域中移除成员

假设你是系统管理员，突然你的应用程序开始出现异常。你查看了日志，但无法理解其中的内容。为了修复这个问题，你需要给开发人员访问权限查看日志。开发人员能够理解问题所在，现在你想要移除该开发人员的会员身份。

准备工作

完成此配方前，你需要在你的机器上安装 rhc。请参考第一章，OpenShift 入门 中的 安装 OpenShift rhc 命令行客户端 配方，获取安装说明。

完成此配方，你将需要两个 OpenShift 账户。请参考第一章，OpenShift 入门 中的 创建 OpenShift Online 账户 配方，获取 OpenShift 账户注册说明。

如何操作…

要从 <openshift.cookbook@gmail.com> 的 osbook 域中移除 openshift.cookbook.test@gmail.com 用户，请运行以下命令：

$ rhc remove-member openshift.cookbook.test@gmail.com --namespace osbook

它是如何工作的…

rhc member-remove 命令执行两个操作：

它将 openshift.cookbook.test@gmail.com 的公共 SSH 密钥从授权密钥注册表中移除，以便 openshift.cookbook.test@gmail.com 无法执行如 git clone 和 SSH 进入应用程序 gear 的 SSH 操作。
它将 openshift.cookbooktest@gmail.com 成员从 osbook 域中移除。

你可以通过插入以下命令来验证 openshift.cookbook.test@gmail.com 是否已从成员列表中移除：

$ rhc members --namespace osbook
Login Role
---------------------------- -------------
openshift.cookbook@gmail.com admin (owner)

还有更多内容…

你可以使用 --all 标志来移除域中的所有成员：

$ rhc remove-member --all --namespace osbook

另见

使用 rhc 向域添加查看者成员 配方
使用 rhc 向域添加管理员成员 配方
使用 rhc 查看域中的所有成员 配方

使用 rhc 限制域的 gear 大小

随着你开始为不同的环境使用不同的域，你可能会感到需要为不同的域限制 gear 大小。特别是，你可能希望为开发环境使用小的 gear，为生产环境使用大的 gear。当你创建应用程序时，你可以为该应用程序指定 gear 大小。然而，这并不太有用，因为它仅适用于该应用程序。为了避免在开发中使用大 gear，你可能希望将开发域仅限制为小的 gear。

准备工作

要完成此操作，您需要在您的计算机上安装 rhc。请参阅第一章，开始使用 OpenShift中的安装 OpenShift rhc 命令行客户端食谱以获取详细说明。

如何操作……

要将devosbook域限制为仅使用小齿轮，请运行以下命令：

$ rhc configure-domain --allowed-gear-sizes small --namespace devosbook

它是如何工作的……

默认情况下，当您创建一个新域时，它会获得您帐户可用的所有齿轮大小的访问权限。当您注册免费帐户时，您只会获得小齿轮的访问权限，这意味着您的操作是有限的。然而，在商业版中，您可以访问更大的齿轮大小。rhc configure-domain命令允许您将一个域限制为特定的齿轮大小。

rhc configure-domain命令要求您指定要在域中允许的齿轮大小列表。命名空间是可选的。如果您不指定域名，则会配置与~/.openshift/express.conf中指定的用户关联的域。您还可以指定多个齿轮大小：

$ rhc configure-domain --allowed-gear-sizes small,medium --namespace devosbook

还有更多……

您还可以通过使用--no-allowed-gear-sizes选项配置一个域，以不允许任何应用程序创建。您将使用此选项来禁止为某个域创建应用程序，或阻止将来使用某个域名。例如，我可以为本书的第二版创建另一个域osbook2，并使用--no-allowed-gear-sizes选项进行配置：

$ rhc configure-domain --no-allowed-gear-sizes --namespace osbook

另见

使用 rhc 向域添加查看员成员食谱
使用 rhc 向域添加管理员成员食谱
使用 rhc 查看域中所有成员食谱

使用 rhc 退出域

现在，您已成为对应于生产环境的域的成员。您已完成工作，现在想要退出生产域。

准备工作

要完成此操作，您需要在您的计算机上安装 rhc。请参阅第一章，开始使用 OpenShift中的安装 OpenShift rhc 命令行客户端食谱以获取详细说明。

如何操作……

要退出一个域，您应该运行以下命令。所有用户都被允许退出他们所在的域：

$ rhc leave-domain --namespace prodosbook -l openshift.cookbook.test@gmail.com

它是如何工作的……

rhc leave-domain命令只需要一个必需的参数，即--namespace，即您要退出的命名空间。然后它会将用户从该域成员中移除。rhc 客户端会发出 REST 删除请求，将成员从命名空间中移除。

另见

使用 rhc 向域添加查看员成员食谱
使用 rhc 向域添加管理员成员食谱
使用 rhc 查看域中所有成员食谱

使用 rhc 删除域

您为测试创建了一个域，现在您不再需要它。自然，您想要删除该域。

准备工作

要完成本食谱中的步骤，你需要在你的机器上安装 rhc。

如何操作…

你应该运行以下命令来删除一个域：

$ rhc delete-domain --namespace testosbook

注意

一旦域被删除，就无法撤销。所以，请谨慎使用此命令。

它是如何工作的…

rhc delete-domain命令通过向 OpenShift 服务发出 REST 删除请求来删除域。如果你的域中包含应用程序，你将无法删除该域。相反，你将收到一条错误消息：

$ rhc delete-domain --namespace testosbook
Deleting domain 'testosbook' ... Domain contains applications. Delete applications first or set force to true.

因此，要通过应用程序删除一个域，你必须传递一个–force标志。这将删除该域及其所有相关的应用程序。

另见

使用 rhc 重命名域食谱

第三章：创建与管理应用程序

本章介绍了一些示例，向你展示如何使用 rhc 命令行客户端开始应用程序开发。你将学习如何通过单个命令创建自己的 OpenShift 应用程序，如何使用应用程序管理操作（如启动、停止和删除），如何为应用程序设置自己的域名，以及如何跟踪和回滚部署。

本章中的具体示例包括：

使用 rhc 命令行客户端创建 OpenShift 应用程序
指定自己的模板 Git 仓库 URL
启动/停止/重启应用程序
添加和管理附加插件
向应用程序添加 cron 插件
使用可下载的插件与 OpenShift 应用程序集成
查看应用程序详情
使用 rhc 克隆应用程序的 Git 仓库
使用 rhc 通过 SSH 连接到应用程序设备
使用 rhc 在应用程序的 SSH 会话中运行命令
设置应用程序特定的环境变量
执行应用程序备份与恢复
跟踪和回滚应用程序部署
配置默认的 Git 分支进行部署
执行手动部署
配置并执行二进制部署
使用自定义域名
清理应用程序
删除应用程序

介绍

OpenShift（或任何其他平台即服务（PaaS））基于一个核心原则，即它应该简化应用程序生命周期管理，包括应用程序的扩展，帮助开发人员更快地构建他们的业务应用程序。这些平台通过为开发人员提供基础设施和应用堆栈的配置、管理和扩展，帮助他们提高生产力。它使软件开发人员能够将自己的创意付诸实践，在本地机器上编写代码，然后在几分钟内将应用程序部署到云端。PaaS 可以在不需要大量工作下，提供一个坚实的基础，帮助你实现下一个商业创意。PaaS 还可以在应用程序从一开始就帮助执行最佳实践，如持续集成。此外，PaaS 还可以帮助你从客户那里获取快速反馈，进而加快迭代速度。

OpenShift 为应用程序开发人员提供了开发和部署应用程序所需的所有服务和工具。运行在 OpenShift 上的应用程序可以利用它们的托管堆栈，并且不需要系统管理员来管理底层平台，从而确保应用程序的安全性和可靠性。OpenShift 提供了可以帮助应用程序开发人员定期备份其应用程序的命令。要了解应用程序开发人员如何备份应用程序，请参考应用程序备份与恢复这一示例。

rhc 命令行工具提供了所有与应用程序相关的命令。要查看所有应用程序相关的命令，请打开命令行终端并运行以下命令：

$ rhc app -h
Usage: rhc app <action>
Creates and controls an OpenShift application. To see the list of all applications use the rhc domain show command. Note that
delete is not reversible and will stop your application and then remove the application and repo from the remote server. No
local changes are made.

我们将在本章中介绍所有这些命令，请继续关注！

每个 OpenShift 应用程序都运行在一个 gear 中，gear 是一个使用 SELinux、Control Groups 和 pam_namespace Linux 技术构建的容器。让我们一一了解这些技术：

SELinux：SELinux（Security Enhanced Linux）是一个由美国国家安全局（NSA）最初开发的 Linux 内核安全模块。OpenShift 使用 SELinux 来实现 gear 隔离并在 gear 周围建立一个加固的安全层。这限制了应用程序 gear 访问它们不应访问的系统部分，比如低层次系统和同一节点上运行的其他应用程序 gear。在多租户环境中，例如 OpenShift，这种行为对于确保在同一基础设施上运行多个应用程序时的安全性和可靠性非常重要。
Control Groups：OpenShift 使用 Control Groups（cgroups），这是 Linux 内核的一个特性，用于在进程组之间分配资源，如 CPU 时间、内存、带宽，或者这些资源的组合。一个 gear 分配的 RAM 和磁盘空间取决于 gear 的大小。在免费层级中，你只能使用小型 gear，它们有 512 MB 的 RAM 和 1 GB 的磁盘空间。我们将在 使用 rhc 命令行客户端创建 OpenShift 应用程序 食谱中介绍 gear 的大小。
pam_namespace：pam_namespace 用于允许每个用户或会话维护自己的目录结构命名空间，防止他们查看或干扰其他用户的命名空间。通过使用这个功能，OpenShift 能够为每个 gear 提供 /tmp 目录。

一个 gear 运行你应用程序的不同软件组件（或 cartridge）。cartridge 是使 gear 有用的东西，它提供应用程序可能需要的软件组件。每个 OpenShift 应用程序都需要一个 web cartridge，并且可以有零个或多个附加和可下载的 cartridge。cartridge 有三种类型：

Web cartridge：这些用于处理网页请求。你不能在没有 Web cartridge 的情况下创建 OpenShift 应用程序。你必须在应用程序创建时指定 Web cartridge。它们支持 Java、PHP、Python、Ruby、Node.js 和 Perl，你可以通过运行以下命令列出所有 Web cartridge：

$ rhc cartridges|grep web
jbossas-7           JBoss Application Server 7              web
jbosseap-6 (*)      JBoss Enterprise Application Platform 6 web
jenkins-1           Jenkins Server                          web
nodejs-0.10         Node.js 0.10                            web
nodejs-0.6          Node.js 0.6                             web
perl-5.10           Perl 5.10                               web
php-5.3             PHP 5.3                                 web
zend-5.6            PHP 5.3 with Zend Server 5.6            web
php-5.4             PHP 5.4                                 web
zend-6.1            PHP 5.4 with Zend Server 6.1            web
python-2.6          Python 2.6                              web
python-2.7          Python 2.7                              web
python-3.3          Python 3.3                              web
ruby-1.8            Ruby 1.8                                web
ruby-1.9            Ruby 1.9                                web
jbossews-1.0        Tomcat 6 (JBoss EWS 1.0)                web
jbossews-2.0        Tomcat 7 (JBoss EWS 2.0)                web
diy-0.1             Do-It-Yourself 0.1                      web

Add-on cartridge：这些是 OpenShift 提供的附加 cartridge。你可以根据需要添加它们，也就是说，如果你的应用程序需要数据库，你将需要添加 MySQL、PostgreSQL 或 MongoDB 附加 cartridge。你可以通过运行以下命令列出所有附加的 cartridge：

$ rhc cartridges|grep addon
10gen-mms-agent-0.1 10gen Mongo Monitoring Service Agent    addon
cron-1.4            Cron 1.4                                addon
jenkins-client-1    Jenkins Client                          addon
mongodb-2.2         MongoDB 2.2                             addon
mysql-5.1           MySQL 5.1                               addon
mysql-5.5           MySQL 5.5                               addon
metrics-0.1         OpenShift Metrics 0.1                   addon
phpmyadmin-4        phpMyAdmin 4.0                          addon
postgresql-8.4      PostgreSQL 8.4                          addon
postgresql-9.2      PostgreSQL 9.2                          addon
rockmongo-1.1       RockMongo 1.1                           addon
switchyard-0        SwitchYard 0.8.0                        addon
haproxy-1.4         Web Load Balancer                       addon

Downloadable cartridge：这使开发人员能够编写自己的 cartridge。开发人员可以编写自己的 cartridge 并通过公共 Git 仓库发布。然后，可以使用 rhc add-cartridge 命令安装它们。我们将在本章的 使用可下载的 cartridge 与 OpenShift 应用程序 食谱中讨论这些内容。

每个 OpenShift 应用程序至少有一个私有 Git 仓库和一个 Web cartridge。它可能有零个或多个附加 cartridge，且可能有零个或多个可下载的 cartridge。一个 OpenShift 应用程序内建支持 Git 版本控制系统、自动化依赖管理、用于文件上传或存储其他文件的持久化数据目录，以及部署回滚。

一个应用程序可以是可扩展的或不可扩展的。可扩展应用程序运行在多个 gear 上，并根据并发用户数水平扩展。我们将在第十一章，日志记录与 OpenShift 应用程序扩展中讨论可扩展应用程序。本章我们将介绍不可扩展应用程序。不可扩展应用程序运行在单个 gear 内，所有的 cartridges 都添加到该 gear 中。这些应用程序适合开发用途，但对于生产环境中的高流量应用程序，你应该考虑使用可扩展应用程序。

使用 rhc 命令行客户端创建 OpenShift 应用程序

在这个教程中，你将学习如何使用 rhc 创建一个 OpenShift 应用程序。我们将创建一个 PHP 5.4 应用程序仅供演示使用。本章将不依赖于特定语言，仅涵盖所有应用程序类型通用的概念。后续章节会介绍 OpenShift 支持的不同编程语言。

准备工作

要逐步执行此教程，你需要在计算机上安装 rhc 命令行客户端。有关详细信息，请参阅第一章，OpenShift 入门中的 安装 OpenShift rhc 命令行客户端 章节。此外，你还应该通过 rhc 设置 OpenShift 账户，具体操作请参考第一章，OpenShift 入门中的 使用 rhc 设置 OpenShift 账户 章节。

如何实现…

要创建一个名为 myapp 的 PHP 5.4 OpenShift 应用程序，打开一个新的命令行终端并运行以下命令：

$ rhc create-app --app myapp --type php-5.4

你也可以避免输入 --app 和 --type 选项，因为 OpenShift 会自动推断它们，如下所示：

$ rhc create-app myapp php-5.4

你也可以这样写命令：

$ rhc app-create myapp php-5.4

所有的 rhc 命令都可以使用 rhc <名词>-<动词> 或 rhc <动词>-<名词> 的形式。

工作原理……

让我们逐步了解 rhc create-app 命令所执行的所有步骤：

rhc create-app 命令需要两个必选选项：--app 和 --type。虽然不要求你在命令中传递这些选项，但你需要提供其值，如 rhc create-app myapp php-5.4 命令所示。这两个选项指定了应用程序名称和应用程序将使用的 Web 组件。OpenShift 服务器将检查应用程序名称和 Web 组件名称是否正确。有效的应用程序名称必须仅包含字母数字字符，且长度最多为 32 个字符。你可以使用以下命令查看所有可用的 Web 组件：
```
$ rhc cartridges|grep web
```
确认应用程序名称和 Web 组件名称正确后，它将检查你的域名中是否有足够的资源来创建应用程序。在免费套餐中，你只能使用三个 gear，因此，如果你尝试在已用完三个 gear 后创建应用程序，你将收到错误响应。例如，如果你已经创建了三个应用程序，并尝试创建第四个应用程序，你将收到错误响应 user has already reached the gear limit of 3。
如果你有足够的资源来创建应用程序，rhc 将发出一个 HTTP POST 请求来创建应用程序。rhc 命令行客户端是 OpenShift REST API 的封装器。OpenShift 服务器将接收到该 POST 请求，并为你的应用程序分配一个 gear。gear 分配的内存和磁盘空间取决于 gear 的大小。在免费套餐中，你只能使用小型 gear，它有 512 MB 的 RAM 和 1 GB 的磁盘空间。如果你在付费套餐中，你可以通过 --gear 选项指定更大的 gear 大小。根据编写时的情况，--gear 的有效值为 small、medium 和 large。
接下来，OpenShift 将安装你的应用程序所需的 Web 组件。在之前创建的应用程序中，它将安装 PHP 5.4 语言运行时和 Apache Web 服务器来处理你的 Web 请求并执行所需的配置。
OpenShift 服务器还将为你的应用程序创建一个私有的 Git 仓库。该 Git 仓库将根据 Web 组件类型提供一个模板应用程序。你可以使用 --from-code 指定自己的模板应用程序。有关内容，请参见下一个配方。
一旦应用程序创建了所有必需的组件，OpenShift 服务器将为你的应用程序创建一个公共 URL，并将其注册到 DNS 中。公共 URL 是应用程序名称和域名的组合。对于之前创建的应用程序，URL 将是 http://myapp-osbook.rhcloud.com。其中，myapp 是应用程序名称，osbook 是域名。你也可以使用你自己的自定义域名与 OpenShift 应用程序一起使用。有关内容，请参见 使用自定义域名 配方。
在应用程序的 DNS 名称可用后，rhc 将使用 Git 命令行工具在你的本地机器上克隆应用程序的 Git 仓库。

最后，你将看到应用程序的详细信息。你可以在http://myapp-{domain-name}.rhcloud.com/查看运行中的应用程序。请将{domain-name}替换为你的账户域名。以下是一个示例：

Your application 'myapp' is now available.

 URL:        http://myapp-osbook.rhcloud.com/
 SSH to:     52ef686d4382ec39f500001a@myapp-osbook.rhcloud.com
 Git remote: ssh://52ef686d4382ec39f500001a@myapp-osbook.rhcloud.com/~/git/myapp.git/
 Cloned to:  /home/vagrant/dev/apps/myapp

让我们看一下本地计算机上的myapp应用程序目录。应用程序创建后，本地计算机会创建一个与应用程序名称相同的目录，其中包含 OpenShift 创建的模板应用程序的源代码，如下所示：

$ ls -a
.git  .openshift index.php

让我们逐一查看这些组件，如下所示：

.git目录存储myapp应用程序的 Git 版本库。该目录包含版本库的完整历史记录。.git/config文件包含版本库的配置。rhc 命令行工具还会将应用程序特定的元数据添加到.git/config文件中。应用程序特定的元数据位于 rhc 部分：
```
[rhc]
app-id = 52ef686d4382ec39f500001a
app-name = myapp
domain-name = osbook
```
.openshift目录存储 OpenShift 特定的文件。.openshift目录下有三个子目录——action_hooks、cron和markers：
- action_hooks目录存储可执行脚本，为应用程序开发人员提供了进入各种应用程序和平台生命周期操作的入口点。使用 action hook 的一个例子是，在应用程序部署后发送电子邮件。
- cron目录存储可执行脚本，可以按计划定期运行。我们将在本章稍后的向应用程序添加 cron 模块配方中详细讲解。
- markers目录允许用户指定设置，例如热部署、调试和要使用的 Java 版本。由于这些设置特定于 Web 模块，我们将在专门讲解 Web 模块的章节中详细说明它们。
index.php文件包含一个简单的 PHP 应用程序，当你访问应用程序 URL 时会看到它。

注意

在撰写本书时，免费层级中的应用程序在 24 小时不活跃后将会空闲。空闲意味着没有来自外部设备对你的应用程序 URL 的 HTTP 请求。当空闲时，设备需要几秒钟才能唤醒并开始处理 Web 请求。

还有更多

如果应用程序创建时间超过 120 秒，rhc命令行工具将抛出异常。为了解决与超时相关的错误，你可以指定--timeout选项，如下所示的代码所示。超时值为秒：

$ rhc app-create myapp php-5.4 --timeout 300

你也可以在~/.openshift/express.conf文件中配置超时设置，如下所示的代码所示。这将适用于所有命令：

# The default timeout for network operations
timeout=300

另见

第一章中的使用 Web 控制台创建 WordPress 应用程序 配方，开始使用 OpenShift
指定你自己的模板 Git 仓库 URL 配方
向应用程序添加 cron 模块 配方
查看应用程序详情 配方
使用自定义域名配方

指定自己的模板 Git 仓库 URL

在使用 rhc 命令行客户端创建 OpenShift 应用配方中，我们创建了一个使用 OpenShift 提供的模板源代码的应用。假设你希望 OpenShift 使用你的 Git 仓库来填充应用的初始内容。这可以通过在创建应用时使用--from-code选项来实现。

准备工作

要完成此配方，你需要在机器上安装 rhc 命令行客户端。有关详细信息，请参阅第一章中的安装 OpenShift rhc 命令行客户端配方，OpenShift 入门。你还应该通过按照第一章中的使用 rhc 设置 OpenShift 账户配方来完成 OpenShift 账户的设置。

操作步骤……

若要创建一个使用自己 Git 仓库初始内容的应用，请使用--from-code选项：

$ rhc create-app javaapp jbosseap-6 --from-code https://github.com/OpenShift-Cookbook/chapter3-recipe2.git

注意

Git 仓库 URL 应该是一个公开的 Git 仓库；否则，应用创建将失败，因为 OpenShift 无法访问该仓库。

工作原理……

当你使用--from-code选项创建 OpenShift 应用时，OpenShift 服务器将首先克隆提供的 Git 仓库，并使用该仓库的源代码填充应用的初始内容。Git 仓库 URL 应该是一个公开的 Git 仓库；否则，OpenShift 将无法克隆该仓库，且会抛出异常。接下来，OpenShift 将构建源代码，创建一个工件，并将该工件部署到服务器上。工件是软件开发过程中产生的副产品，例如，在 Java 应用中，它可能是Java 归档文件（JAR）、Web 归档文件（WAR）或企业归档文件（EAR）文件。

在前面的命令中，我们创建了一个使用公开 Git 仓库 URL 作为初始代码的 JBoss EAP 应用。应用成功创建后，你可以在http://javaapp-{domain-name}.rhcloud.com/查看该应用。该应用是一个简单的演示，展示了名为 Boilerpipe 的文章提取库（你可以访问code.google.com/p/boilerpipe/）。它接受一个 URL 并提取该 URL 的标题和相关文本。

另见

使用 Web 控制台创建 WordPress 应用配方，见第一章，OpenShift 入门
使用 rhc 命令行客户端创建 OpenShift 应用配方

启动/停止/重启应用

rhc 命令行客户端提供了启动、停止和重启应用程序的命令。在本配方中，你将学习如何使用 rhc 执行这些命令。

准备工作

要按照本配方逐步操作，你需要在机器上安装 rhc。此外，我们将使用 使用 rhc 命令行客户端创建 OpenShift 应用程序 配方中创建的 OpenShift 应用程序。

如何操作…

要启动应用程序，请运行以下命令：

rhc start-app --app myapp

要停止应用程序，请运行以下命令：

rhc stop-app --app myapp

要重启应用程序，请运行以下命令：

rhc restart-app –-app myapp

如果你在应用程序的 Git 仓库中运行命令，则 --app 选项不是必需的。当你在仓库中运行命令时，rhc 会从 .git/config Git 仓库配置文件中找到域名和应用程序名称。它使用 git config --get rhc.domain-name 命令来找到域名，使用 git config --get rhc.app-name 来找到应用程序名称。

它是如何工作的…

rhc 启动/停止/重启应用程序的命令让你可以使用 rhc 管理应用程序。rhc 客户端发出一个 POST HTTP 请求来停止应用程序，从而停止 Web 插件和附加插件。每个 OpenShift gear 上都有一个可执行文件叫做 gear。当服务器接收到 POST 请求时，它会执行 gear stop 命令来停止 PHP 5.4 插件。在应用程序成功停止后，向应用程序 URL 发出的 curl 请求将返回 503 错误：

$ curl http://myapp-osbook.rhcloud.com
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>503 Service Temporarily Unavailable</title>
</head><body>
<h1>Service Temporarily Unavailable</h1>
<p>The server is temporarily unable to service your
request due to maintenance downtime or capacity
problems. Please try again later.</p>
<hr>
<address>Apache/2.2.22 (Red Hat Enterprise Web Server) Server at myapp-osbook.rhcloud.com Port 80</address>
</body></html>

rhc start-app 命令会发出一个 POST HTTP 请求来启动应用程序。OpenShift 服务器接收到 POST 请求后，会在应用程序 gear 上调用 gear start 命令。gear start 命令会首先启动所有附加插件，然后才启动 Web 插件。

rhc restart-app 命令首先通过在应用程序 gear 上调用 gear stop 命令来停止应用程序，然后通过在应用程序 gear 上调用 gear start 命令来启动应用程序。

还有更多…

rhc stop-app 命令仅停止 Web 插件和附加插件进程，但如果你想终止应用程序 gear 中运行的所有进程，你应该使用 rhc force-stop-app 命令。这个命令会终止 gear 中运行的所有进程。当有人在应用程序中运行自己的进程时，这个命令非常有用。在这种情况下，rhc app-stop 命令无法起作用：

$ rhc force-stop-app --app myapp

另见

使用 rhc 命令行客户端创建 OpenShift 应用程序 配方
查看应用程序详细信息 配方

添加和管理附加插件

在 使用 rhc 命令行客户端创建 OpenShift 应用程序 配方中，你学习了如何使用 Web 插件创建一个新的 OpenShift 应用程序。除了 Web 插件，OpenShift 还支持多种附加插件。这些插件提供了数据库、监控、定时任务、数据库 Web 客户端等功能。

在此配方中，您将学习如何将 MySQL 5.5 插件安装到您在 使用 rhc 命令行客户端创建 OpenShift 应用程序 配方中创建的 PHP 5.4 应用程序上。

准备就绪

要完成此配方，您需要在您的机器上安装 rhc。同时，我们将使用在 使用 rhc 命令行客户端创建 OpenShift 应用程序 配方中创建的 OpenShift 应用程序。

如何操作…

要将 MySQL 5.5 插件添加到我们的应用程序，请运行以下命令：

$ rhc cartridge-add --app myapp --cartridge mysql-5.5

如果您想启动插件，请运行以下命令：

$ rhc cartridge-start --app myapp --cartridge mysql-5.5

要停止一个插件，请运行以下命令：

$ rhc cartridge-stop --app myapp --cartridge mysql-5.5

要重启一个插件，请运行以下命令：

$ rhc cartridge-restart --app myapp --cartridge mysql-5.5

您还可以使用以下命令查看插件状态：

$ rhc cartridge-status --app myapp --cartridge mysql-5.5

最后，要移除插件，请运行以下命令：

$ rhc cartridge-remove --app myapp --cartridge mysql-5.5 --confirm

--confirm 选项用于确认插件移除。如果您没有指定 --confirm 选项，OpenShift 会要求您确认操作。

它是如何工作的…

所有与插件相关的命令都可以在 rhc cartridge 下找到。要查看您可以在插件上执行的所有操作，请运行以下命令：

$ rhc cartridge -h
List of Actions
 add           Add a cartridge to your application
 list          List available cartridges
 reload        Reload the cartridge's configuration
 remove        Remove a cartridge from your application
 restart       Restart a cartridge
 scale         Set the scale range for a cartridge
 show          Show useful information about a cartridge
 start         Start a cartridge
 status        Get current the status of a cartridge
 stop          Stop a cartridge
 storage       View/manipulate storage on a cartridge

rhc cartridge-add 命令发出一个 HTTP POST 请求，将 MySQL 5.5 插件添加到 myapp 应用程序中。该命令行工具在当前命令行目录的上下文中运行，并与 OpenShift REST API 进行交互。这样可以避免在每个命令中都使用 --app 选项指定应用程序名称。服务器接收到 POST 请求并在应用程序的 gear 上安装 MySQL 二进制文件。成功创建应用程序后，您将收到以下结果：

mysql-5.5 (MySQL 5.5)
---------------------
 Gears:          Located with php-5.4
 Connection URL: mysql://$OPENSHIFT_MYSQL_DB_HOST:$OPENSHIFT_MYSQL_DB_PORT/
 Database Name:  myapp
 Password:       2L5FIzuyZrXa
 Username:       adminyEY1pty

Added mysql-5.5 to application myapp
MySQL 5.5 database added.  Please make note of these credentials:
 Root User: adminyEY1pty
 Root Password: 2L5FIzuyZrXa
 Database Name: myapp

Connection URL: mysql://$OPENSHIFT_MYSQL_DB_HOST:$OPENSHIFT_MYSQL_DB_PORT/

You can manage your new MySQL database by also embedding phpmyadmin.
The phpmyadmin username and password will be the same as the MySQL credentials above.

剩余的命令不言自明，因此不需要太多讨论。

注意

请注意，rhc remove-cartridge 命令是不可逆操作，且您在移除插件后无法恢复数据。

还有更多…

您还可以使用 rhc cartridge 命令查看插件的详细信息：

$ rhc show-cartridge mysql –-app myapp
Using mysql-5.5 (MySQL 5.5) for 'mysql'
mysql-5.5 (MySQL 5.5)
---------------------
 Gears:          Located with php-5.4
 Connection URL: mysql://$OPENSHIFT_MYSQL_DB_HOST:$OPENSHIFT_MYSQL_DB_PORT/
 Database Name:  myapp
 Password:       2L5FIzuyZrXa
 Username:       adminyEY1pty

查看更多

使用 rhc 命令行客户端创建 OpenShift 应用程序 配方
查看应用程序详情 配方
向应用程序添加 cron 插件 配方

向应用程序添加 cron 插件

在这个配方中，您将学习如何将 cron 插件添加到您的应用程序中。cron 插件将每小时将 quota 命令的输出写入文件。数据库和其他插件将在本书后续部分进行讲解。

准备就绪

为了准备此配方，您需要在您的机器上安装 rhc。同时，我们将使用在 使用 rhc 命令行客户端创建 OpenShift 应用程序 配方中创建的 OpenShift 应用程序。

如何操作…

执行以下步骤将 cron 插件添加到您的应用程序：

打开一个新的命令行终端并运行以下命令：
```
$ rhc add-cartridge --cartridge cron --app myapp
```
在应用程序根目录下创建一个新的 quota.txt 文件，并用以下代码填充它。在 *nix 系统上，你可以使用 cat 命令，如以下命令行所示：
```
$ echo "# Quote File" >> quota.txt
```
在 Windows 系统上，你可以使用文件资源管理器创建新文件。创建文件后，写入 # Quota File。

添加 cron 插件后，在 .openshift/cron/hourly 文件夹中创建一个名为 quota.sh 的新文件，并将以下内容添加到其中：

#!/bin/bash
date >> $OPENSHIFT_REPO_DIR/quota.txt
quota -s >> $OPENSHIFT_REPO_DIR/quota.txt
echo "**********************************************************************************************" >> $OPENSHIFT_REPO_DIR/quota.txt

通过运行以下命令使 quota.sh 脚本可执行。在 *nix 系统上，你可以运行以下命令：
```
$ chmod +x .openshift/cron/hourly/quota.sh
```
在 Windows 系统上，由于没有 chmod 命令，你必须使用以下命令：
```
$ git update-index --add --chmod=+x .openshift/cron/hourly/quota.sh
```
将 quota.sh 脚本添加到 Git 仓库中，然后将更改提交到本地 Git 仓库：
```
$ git add .
$ git commit -am "added hourly script to output quota limits"
```
将更改推送到 OpenShift 服务：
```
$ git push
```
部署更改后，你将在 http://myapp-{domain-name}.rhcloud.com/quota.txt 查看配额信息。

工作原理…

每个 OpenShift 应用程序在 .openshift 目录下都有一个 cron 目录。这个目录用于定义每分钟、每小时、每天、每周或每月运行的作业。在你使用 rhc add-cartridge 命令将 cron 插件添加到应用程序之前，cron 作业不会被触发。它们非常适用于定期在后台自动执行任务。你可以用它们来执行数据库备份、清理日志文件、发送电子邮件等等。

在第 1 步中，你已将 cron 插件添加到 myapp 应用程序中。接下来，在第 3 步中，你定义了一个每小时运行的 quota.sh bash 脚本。quota.sh 脚本会将日期和配额信息附加到 OpenShift 仓库位置下 php 目录中的 quota.txt 文件中。$OPENSHIFT_REPO_DIR 是一个环境变量，指向应用程序源代码目录的位置。在第 4 步中，你使 quota.sh 脚本可执行，若没有此步骤，OpenShift 服务将无法执行该脚本。在接下来的三步中，你将更改提交到本地 Git 仓库，然后将更改推送到托管在 OpenShift 应用程序 gear 上的应用程序 Git 仓库。OpenShift 会先停止整个插件，构建应用程序，将其部署到 Apache 服务器上，然后最后启动所有插件。cron 插件启动后，它将每小时写入 quota.txt 文件。你可以通过访问 http://myapp-{domain-name}.rhcloud.com/quota.txt 查看配额详情：

Tue Feb  4 02:57:14 EST 2014 Disk quotas for user 52f08f184382ecb8e9000239 (uid 2675):       Filesystem  blocks   quota   limit   grace   files   quota   limit   grace /dev/mapper/EBSStore01-user_home01                    9760       0   1024M             359       0   80000         ********************************************************************************************** Tue Feb  4 03:57:14 EST 2014 Disk quotas for user 52f08f184382ecb8e9000239 (uid 2675):       Filesystem  blocks   quota   limit   grace   files   quota   limit   grace /dev/mapper/EBSStore01-user_home01                    9760       0   1024M             359       0   80000         **********************************************************************************************

注意

默认情况下，cron 作业的超时时间为 5 分钟，这意味着你的作业应该在 5 分钟内完成，否则将被终止。

你可以使用 nohup 在后台运行更长时间的作业：

nohup /path-to/script > $OPENSHIFT_LOG_DIR/logfile 2>&1 &

还有更多内容…

OpenShift 当前只支持每分钟、每小时、每天、每周或每月间隔调度任务。如果你希望在特定时间或特定间隔运行任务，例如在每天晚上 8:30 运行一个任务，你可以创建一个每分钟运行的任务，然后添加以下代码。该任务只有在 8:30 PM 时才会执行：

#!/bin/bash
if [ `date +%H:%M` == "20:30" ]
then
    date >> $OPENSHIFT_REPO_DIR/quota_20h_30m.txt
quota -s >> $OPENSHIFT_REPO_DIR/quota_20h_30m.txt
echo "********************************">> $OPENSHIFT_REPO_DIR/quota_20h_30m.txt
fi

另请参见

使用 rhc 命令行客户端创建 OpenShift 应用程序 这篇教程

使用可下载插件与 OpenShift 应用程序

在这个教程中，你将学习如何将第三方可下载插件与 OpenShift 应用程序一起使用。

准备工作

要按照本教程进行操作，你需要在你的机器上安装 rhc。同时，我们将使用在 使用 rhc 命令行客户端创建 OpenShift 应用程序 这篇教程中创建的 OpenShift 应用程序。

操作步骤…

要添加 Monit 可下载插件，请使用如下命令中的 rhc add-cartridge 命令。请将 email@address.com 替换为你有效的电子邮件地址：

$ rhc cartridge-add --app myapp https://raw.githubusercontent.com/openshift-cartridges/openshift-origin-cartridge-monit/master/metadata/manifest.yml --env MONIT_ALERT_EMAIL=email@address.com

--env 选项用于设置此插件所需的环境变量。该插件需要 MONIT_ALERT_EMAIL 环境变量，用于配置将用于发送警报通知的电子邮件。环境变量将在 设置应用程序特定环境变量 这篇教程中详细介绍。

工作原理…

要将一个第三方可下载的插件安装到你的应用程序中，你需要提供 rhc 命令行客户端该插件清单文件的 URL，该文件名为 manifest.yml。此文件位于插件源代码库中的 metadata 目录下，并包含一个指向插件实际内容的 URL。可以在 www.openshift.com/developers/download-cartridges 找到一个积极维护的第三方插件列表。另一种寻找可下载插件的好方法是搜索 GitHub (github.com/search?q=%22openshift+cartridge%22)，因为大多数插件托管在 GitHub 上。

你可以稍后通过运行 rhc remove-cartridge 命令来移除插件：

$ rhc remove-cartridge monit --confirm

另请参见

使用 rhc 命令行客户端创建 OpenShift 应用程序 这篇教程
添加和管理附加插件 这篇教程
将 cron 插件添加到应用程序 这篇教程

查看应用程序详细信息

在这个教程中，你将学习如何查看与应用程序相关的所有详细信息。

准备工作

操作步骤…

rhc show-app 命令可以用来查看应用程序的详细信息，操作如下：

$ rhc show-app --app myapp

如果你在应用程序 Git 仓库内运行命令，则不需要 --app 选项。

工作原理…

rhc show-app命令返回应用程序的所有详细信息。命令的输出如下所示。详细信息包括应用程序的创建时间、应用程序名称、公共 URL、Git 仓库 URL、SSH URL 以及所有 cartridge 的详细信息：

rhc show-app --app myapp
myapp @ http://myapp-osbook.rhcloud.com/ (uuid: 52f08f184382ecb8e9000239)
-------------------------------------------------------------------------
 Domain:     osbook
 Created:    1:56 AM
 Gears:      1 (defaults to small)
 Git URL:    ssh://52f08f184382ecb8e9000239@myapp-osbook.rhcloud.com/~/git/myapp.git/
 SSH:        52f08f184382ecb8e9000239@myapp-osbook.rhcloud.com
 Deployment: auto (on git push)

 php-5.4 (PHP 5.4)
 -----------------
 Gears: Located with cron-1.4

 cron-1.4 (Cron 1.4)
 -------------------
 Gears: Located with php-5.4

你还可以通过传入--state选项来查看应用程序的状态，如下所示的命令。有效的应用程序状态包括started（启动）、stopped（停止）和building（构建中）：

$ rhc show-app --app myapp --state
Cartridge php-5.4, cron-1.4 is started

如果你只想查看应用程序中所有 gear 的 SSH 信息和状态，可以使用--gears选项与rhc app-show命令一起：

$ rhc show-app--app --gears
ID                       State   Cartridges       Size  SSH URL
------------------------ ------- ---------------- ----- -------------------------------------------------
52f08f184382ecb8e9000239 started php-5.4 cron-1.4 small 52f08f184382ecb8e9000239@myapp-osbook.rhcloud.com

上述命令在处理可扩展应用程序时非常有用，因为它通过单个命令提供了所有应用程序 gear 的信息。

查看更多

使用 rhc 命令行客户端创建 OpenShift 应用程序配方
使用 rhc 克隆应用程序 Git 仓库配方

使用 rhc 克隆应用程序 Git 仓库

在第一章中，将应用程序克隆到本地机器配方，开始使用 OpenShift，你学习了如何使用 Git 命令行工具克隆 Git 仓库。这个配方有几个步骤——首先，从 Web 控制台复制 Git 仓库的 URL，然后使用git-clone命令克隆 Git 仓库。rhc 命令行工具可以帮助你节省一些按键。在这个配方中，你将学习如何使用 rhc 来克隆 Git 仓库。

准备工作

要完成这个配方，你需要在你的机器上安装 rhc。此外，我们将使用在使用 rhc 命令行客户端创建 OpenShift 应用程序配方中创建的 OpenShift 应用程序。

如何操作…

要使用 rhc 在本地机器上克隆myapp应用程序，运行以下命令：

rhc git-clone --app myapp

它是如何工作的…

rhc git-clone命令首先发送一个 HTTP GET 请求以获取关于myapp应用程序的详细信息。应用程序的详细信息包括 Git 仓库 URL。然后，rhc git-clone命令使用git clone <GIT_REPOSITORY_URL>命令来克隆该应用程序。

注意

rhc git-clone命令需要在你的机器上安装 Git 才能正常工作。

还有更多内容…

你还可以告诉rhc git-clone命令使用--repo选项将仓库克隆到特定目录。以下命令将在tmp/myapp文件夹中克隆仓库：

$ rhc git-clone --app myapp --repo ../tmp/myapp

查看更多

使用 rhc 命令行客户端创建 OpenShift 应用程序配方
在第一章中，将应用程序克隆到本地机器配方，开始使用 OpenShift。

使用 rhc 通过 SSH 连接到应用程序的 gear

在这个配方中，你将学习如何使用 rhc 通过 SSH 连接到应用程序的 gear。

准备工作

为了完成本食谱，你需要在你的机器上安装 rhc。此外，你还需要使用在 使用 rhc 命令行客户端创建 OpenShift 应用程序 食谱中创建的 OpenShift 应用程序。

如何操作…

要 SSH 登录到应用程序 gear，请打开一个新的命令行终端并运行以下命令：

$ rhc ssh --app myapp

如果你在应用程序 Git 仓库中运行命令，则无需使用 --app 选项。

它是如何工作的…

每个 OpenShift 应用程序 gear 都像一个虚拟服务器，你可以通过 SSH 访问它。每个 gear 都会分配一个唯一的用户 ID，并与 SELinux 上下文相关联。当你运行 rhc ssh 命令时，会在托管 gear 的节点与本地机器之间打开一个安全通信通道，并在环境中提供一个有限的 shell，如下所示的命令。我已简化部分输出：

Connecting to 52f08f184382ecb8e9000239@myapp-osbook.rhcloud.com ...

 Welcome to OpenShift shell
This shell will assist you in managing OpenShift applications.

 !!! IMPORTANT !!! IMPORTANT !!! IMPORTANT !!!
 Shell access is quite powerful and it is possible for you to
 accidentally damage your application.  Proceed with care!
 If worse comes to worst, destroy your application with "rhc app delete"
 and recreate it
 !!! IMPORTANT !!! IMPORTANT !!! IMPORTANT !!!

 Type "help" for more info.
[myapp-osbook.rhcloud.com 52f08f184382ecb8e9000239]\>

如果你运行 ls 命令，你将只看到应用程序用户主目录下所有可用的目录：

[myapp-osbook.rhcloud.com 52f08f184382ecb8e9000239]\> ls
app-deployments  app-root  cron  git  php

还有更多…

默认情况下，SSH 连接将在 5 分钟的非活动后超时，你将被注销出 SSH 会话。你可以通过取消设置 TMOUT 环境变量来关闭连接超时：

[myapp-osbook.rhcloud.com 52f08f184382ecb8e9000239]\> unset TMOUT

注意

如果其他人访问你的机器，而你不希望他们仅通过输入 rhc ssh 命令来访问你的 OpenShift 应用程序，我建议你使用 SSH 密钥密码短语来限制访问。我们在第一章的 使用 SSH 密钥密码短语 食谱中讨论了 SSH 密钥密码短语，开始使用 OpenShift。

查看更多

使用 rhc 命令行客户端创建 OpenShift 应用程序 食谱
第一章中的 通过 Web 控制台上传 SSH 密钥 食谱，开始使用 OpenShift
在第一章的 使用 SSH 密钥密码短语 食谱中，开始使用 OpenShift

在应用程序的 SSH 会话中使用 rhc 运行命令

在本食谱中，你将学习如何在不使用 rhc 执行 SSH 登录服务器的情况下查看 gear 目录列表。

准备工作

要执行此食谱，你需要在你的机器上安装 rhc。此外，我们将使用在 使用 rhc 命令行客户端创建 OpenShift 应用程序 食谱中创建的 OpenShift 应用程序。

如何操作…

要在不执行 SSH 登录到应用程序服务器的情况下运行 ls 命令，你应该运行以下命令：

$ rhc app-ssh --app myapp --command ls

rhc ssh 命令是 rhc app-ssh 的简写。这两个命令都允许你 SSH 登录到应用程序 gear。

它是如何工作的…

rhc app-ssh 命令内部使用 SSH 命令行客户端连接到应用程序 gear。通过 SSH 命令行客户端，你可以指定命令：

$ ssh username@server.com command

rhc 命令行客户端提供了一个 --command 选项，允许你指定要在服务器上运行的命令：

$ rhc app-ssh --app myapp --command ls
app-deployments
app-root
cron
git
php

还有更多…

如果你希望在应用的所有 gears 上运行命令，应该在 rhc app-ssh 命令中使用 --gears 选项。当处理可扩展应用时，这将非常有用。看看以下命令：

$ rhc app-ssh --app myapp --gears --command ls

查看更多

使用 rhc 命令行客户端创建 OpenShift 应用 配方
使用 rhc SSH 连接到应用 gear 配方

设置特定于应用的环境变量

很常见的情况是人们将他们的应用部署到多个环境中，如测试、预发布和生产环境。通常，这些环境之间的配置会有所不同，以确保在正确的环境中使用正确的服务。考虑一个例子：你想在应用中发送电子邮件。在生产环境中，你可能希望使用云邮件服务，如 Sendmail（可通过 www.sendmail.com/ 访问），而在开发环境中，你可能希望使用开源版本的 Sendmail。环境变量为这些问题提供了与编程语言和操作系统无关的解决方案。

将配置值硬编码在源代码中永远不是一个好主意，因为这会导致你的代码和这些值之间的强耦合，若代码落入不法之手，还会危及应用的安全性。环境变量让你可以在不同环境中使用相同的应用代码，从而实现可移植的代码。

OpenShift 还暴露了一些你应该在应用程序中使用的环境变量，而不是将其值硬编码。例如，如果你想在 OpenShift 应用中写入文件，你应该使用 OPENSHIFT_DATA_DIR 环境变量来访问持久目录的位置。每个 OpenShift 卡带也会暴露自己的环境变量。例如，PostgreSQL 卡带暴露了用于用户名、密码、主机、端口等的环境变量。你不应将数据库配置属性硬编码在源代码中，而应利用环境变量。你可以通过运行以下命令查看所有 OpenShift 和特定卡带的环境变量。rhc ssh 命令是 rhc app-ssh 的简写。这两个命令都允许你通过 SSH 连接到应用的 gear：

$ rhc ssh --command env
MANPATH=/opt/rh/php54/root/usr/share/man:
OPENSHIFT_PHP_IDENT=redhat:php:5.4:0.0.10
OPENSHIFT_GEAR_MEMORY_MB=512
SELINUX_ROLE_REQUESTED=
GEM_HOME=/var/lib/openshift/52f08f184382ecb8e9000239/.gem
OPENSHIFT_DEPLOYMENT_TYPE=git
SHELL=/usr/bin/oo-trap-user
TMPDIR=/tmp/
SSH_CLIENT=117.207.187.145 15958 22
OPENSHIFT_DEPLOYMENTS_DIR=/var/lib/openshift/52f08f184382ecb8e9000239/app-deployments/
OPENSHIFT_TMP_DIR=/tmp/
SELINUX_USE_CURRENT_RANGE=
OPENSHIFT_REPO_DIR=/var/lib/openshift/52f08f184382ecb8e9000239/app-root/runtime/repo/
OPENSHIFT_HOMEDIR=/var/lib/openshift/52f08f184382ecb8e9000239/
OPENSHIFT_GEAR_NAME=myapp
PHPRC=/var/lib/openshift/52f08f184382ecb8e9000239/php//configuration/etc/php.ini
OPENSHIFT_PYPI_MIRROR_URL=http://mirror1.ops.rhcloud.com/mirror/python/web/simple
OPENSHIFT_CRON_DIR=/var/lib/openshift/52f08f184382ecb8e9000239/cron/
OPENSHIFT_APP_SSH_PUBLIC_KEY=/var/lib/openshift/52f08f184382ecb8e9000239/.openshift_ssh/id_rsa.pub
OPENSHIFT_CLOUD_DOMAIN=rhcloud.com
USER=52f08f184382ecb8e9000239
..// Removed for brevity

正如你在前一个命令的结果中看到的，列表中还包括我们在上一个配方中添加的 cron 卡带的特定环境变量。

在本配方中，你将学习如何创建特定于应用的环境变量。

准备就绪

要完成此配方，你需要在机器上安装 rhc。此外，你还需要使用在 使用 rhc 命令行客户端创建 OpenShift 应用 配方中创建的 OpenShift 应用。

如何操作…

执行以下步骤来设置特定于应用程序的环境变量：

要创建一个特定于应用程序的环境变量，打开一个新的命令行终端并运行以下命令：
```
rhc env-set --app myapp --env MY_APP_ENV="Hello OpenShift Environment Variables"
```

要测试环境变量，打开 myapp 文件夹中的 index.php 文件，如下所示：

<hgroup>
<h1>Welcome to your PHP application on OpenShift</h1>
</hgroup>

然后，在文件中进行以下更改：

<hgroup>
<h1>
<?php
echo($_ENV["MY_APP_ENV"]);
?>

</h1>
</hgroup>

最后，提交更改并将其推送到应用程序 gear：

git commit –am "added environment variable in index.php"
git push

成功推送后，访问 http://myapp-osbook.rhcloud.com/ 来查看更改。

它是如何工作的…

rhc env-set 命令允许开发者设置特定于应用程序的环境变量。运行 rhc env-set 命令时，会发生以下操作：

rhc 命令行客户端会发出一个 HTTP POST 请求，环境变量数据包含在请求体中。
OpenShift 经纪人接收到请求并进行一些验证。如果验证失败，用户将看到错误消息。
通过验证检查后，经纪人将创建任务来更新所有应用程序 gear 的新环境变量。

完成后，用户将看到成功消息：

Setting environment variable(s) ... done

注意

环境变量在你重新启动应用程序之前是不可用的。因此，在设置环境变量后，使用 rhc app-restart 命令重启应用程序。

你不仅可以一次设置一个环境变量，还可以一次设置多个环境变量：

rhc env-set –app myapp –env MY_APP_ENV1=test1 MY_APP_ENV2=test2

设置多个环境变量的另一种替代方法是使用文件存储环境变量，并将该文件传递给 rhc env-set 命令。你应该创建一个名为 envs.txt 的新文件，并在每一行输入一个环境变量：

MY_APP_ENV1=test
MY_APP_ENV2=

现在，你可以将 envs.txt 文件传递给 rhc env-set 命令，如下所示：

rhc env-set –app myapp envs.txt

如果你想查看所有应用程序特定的环境变量，可以运行以下命令：

rhc env-list –app myapp

还有更多…

要更新环境变量的值，你应该运行 rhc env-set 命令并提供新值，如下所示：

rhc env-set --app myapp --env MY_APP_ENV="Hello World"

要删除环境变量，运行以下命令：

$ rhc env-remove --env MY_APP_ENV –confirm

查看更多

使用 rhc 命令行客户端创建 OpenShift 应用程序 教程
查看应用程序详细信息 教程

备份和恢复应用程序

在现实世界中，事情随时可能出错，你应该始终备份整个应用程序，以便在出现问题时可以恢复应用程序到正常状态。一个 OpenShift 应用程序由 Git 仓库、一个或多个数据库、环境变量和一个你应该备份的持久化数据目录组成。你可以使用命令行工具，如 mysqldump、pg_dump 和 mongoexport 来进行数据库备份，但这些工具仅备份各自的数据库。我们将在后面的章节中讨论数据库备份。在本教程中，你将学习如何使用 rhc 进行备份和恢复。

准备工作

为了准备这个配方，你需要在你的机器上安装 rhc。同时，你还需要利用在 使用 rhc 命令行客户端创建 OpenShift 应用 配方中创建的应用。

如何操作…

要为应用创建备份，请打开命令行终端并运行以下命令：
```
$ rhc snapshot-save --app myapp --filepath myapp-backup.tar.gz
```

更改 php 目录下的 index.php，将标题更改为以下内容：

<h1>
   Welcome to your PHP application running on OpenShift
</h1>

将更改提交到本地仓库，并将更改推送到应用的远程 Git 仓库以部署更改，如下所示：
```
$ git commit -am "updated header in index.php"
$ git push
```
访问 http://myapp-{domain-name}.rhcloud.com/ 查看你的更改。

要从备份中恢复应用，运行以下命令：

$ rhc restore-snapshot --filepath myapp-backup.tar.gz

现在，在应用备份后，如果你访问 http://myapp-{domain-name}.rhcloud.com/，你会注意到我们所做的更改已被恢复，因为我们应用了在第 2 步更改之前所拍摄的快照。

它是如何工作的…

现在让我们来了解你在前面部分提到的步骤中做了什么。在第 1 步，你运行了 rhc snapshot-save 命令来创建应用备份。rhc 工具首先通过向 OpenShift 经纪人发送 HTTP GET 请求来获取应用的详细信息。应用详细信息包括应用的 SSH URL。获取 SSH URL 后，rhc 命令行客户端执行了 ssh <application_ssh_url>'snapshot'>../backup/myapp-backup.tar.gz 命令来备份应用。这使用了 SSH 命令行功能在远程服务器上运行命令。快照命令的输出会写入本地机器上的 myapp-backup.tar.gz 文件。该 rhc snapshot-save 命令不需要 --filepath 选项，默认会创建一个与应用同名的 TAR 文件，并写入当前目录。该命令首先停止应用，然后创建应用 Gear 主目录下所有目录的备份。这包括应用 Git 仓库、数据目录、所有 cartridge 及其数据以及环境变量。你可以使用以下命令列出 tar.gz 文件的内容：

$ tar -ztf myapp-backup.tar.gz

通过前面列表中的第 2 步到第 4 步，你在 index.php 中做了一些小更改，将更改推送到应用的 Gear 上，然后通过访问应用 URL 查看更改。这是为了测试恢复功能。

第 5 步使用rhc snapshot-restore命令恢复了你在第 1 步中制作的应用备份。rhc 命令行客户端首先发出 HTTP GET 请求以获取应用的 SSH URL。获取到 SSH URL 后，rhc 命令行客户端执行cat '../backup/myapp-backup.tar.gz' | ssh <application_ssh_url>'restore INCLUDE_GIT'命令来恢复备份。该命令将cat命令的标准输出通过管道传输到 SSH 命令的标准输入。恢复命令会在替换应用服务器主目录中的所有目录之前停止应用程序。

最后，在第 6 步中，你验证了第 2 步所做的更改已经被撤销，因为你应用了一个不包含第 2 步更改的备份。

注意

rhc snapshot命令会停止应用程序，然后运行save或restore命令。

还有更多内容…

rhc snapshot命令还可以接受另一个选项--ssh。该选项可以用来指定不同的 SSH 客户端和/或传递 SSH 选项。假设你想打印 SSH 调试信息，你可以使用 SSH 客户端的-v选项：

rhc snapshot-save --app myapp --filepath ../backup/myapp-backup.tar.gz --ssh 'ssh -v'

这将打印所有 SSH 调试信息。为了简洁起见，我只展示了部分输出：

Creating and sending tar.gz
debug1: client_input_channel_req: channel 0 rtype exit-status reply 0
debug1: client_input_channel_req: channel 0 rtype eow@openssh.com reply 0
debug1: channel 0: free: client-session, nchannels 1
debug1: fd 1 clearing O_NONBLOCK
Transferred: sent 2688, received 207872 bytes, in 19.0 seconds
Bytes per second: sent 141.2, received 10915.6
debug1: Exit status 0
RESULT:
Success

另请参见

使用 rhc 命令行客户端创建 OpenShift 应用教程
跟踪和回滚应用部署教程

跟踪和回滚应用部署

当你使用git push部署源代码时，OpenShift 会执行一个新的构建，创建一个部署，将其部署到相应的服务器上，然后启动你的应用容器。默认情况下，它只会跟踪你应用的最后一次部署，这意味着你无法回滚到以前的部署。在这个教程中，你将学习如何配置你的应用来跟踪多个部署并回滚到某个特定的部署。

准备工作

要完成这个教程，你需要在机器上安装 rhc。

如何操作…

执行以下步骤以学习如何配置应用程序来跟踪多个部署并回滚到以前的版本：

创建一个新的 PHP 5.4 应用，就像我们在使用 rhc 命令行客户端创建 OpenShift 应用教程中创建的那样，步骤如下：
```
$ rhc create-app–-app myapp php-5.4
```
要让一个 OpenShift 应用程序跟踪 10 个部署（例如），你应该运行以下命令：
```
$ rhc configure-app --app myapp --keep-deployments 10
```

在应用目录中对index.php进行更改：

<h1>
   Configured the application to track 10 deployments
</h1>

提交更改并将更改推送到应用服务器，步骤如下：
```
$ git commit -am "enabled deployment tracking"
$ git push
```
在http://myapp-{domai``n-name}.rhcloud.com查看更改。

通过运行以下命令列出所有由应用跟踪的部署：

$ rhc deployment-list --app myapp

7:42 PM, deployment fbaa7582
7:47 PM, deployment ac5d6f39

要回滚到部署 ID 为fbaa7582的版本，运行以下命令：
```
$ rhc deployment-activate --app myapp --id fbaa7582
```

你可以通过再次运行rhc deployment-list命令来验证回滚是否发生：

$ rhc deployment-list --app myapp
7:42 PM, deployment fbaa7582
7:47 PM, deployment ac5d6f39 (rolled back)
7:50 PM, deployment fbaa7582 (rollback to 7:42 PM)

它是如何工作的…

在步骤 1 中，你创建了一个新的 PHP 5.4 应用程序，然后在步骤 2 中，你配置了该应用程序以使用rhc app-configure命令跟踪 10 次部署。然后，从步骤 2 到步骤 5，你在index.php中进行了简单的更改，并将该更改部署到应用程序 gear。当你将代码推送到应用程序 gear 时，会创建一个新的部署，ID 为ac5d6f39，并存储在app-deployments文件夹中，位于应用程序 gear 的主目录下。你可以通过以下命令查看存储在app-deployments目录中的部署。每个部署都存储在一个以当前时间戳命名的目录中。当前活动的部署存储在当前目录下：

$ rhc ssh --command "ls  ~/app-deployments"
2014-02-09_09-11-31.636
2014-02-09_09-17-22.896
by-id
current

在步骤 6 中，你列出了所有的部署，使用了rhc deployment-list命令。rhc deployment-list命令列出了所有跟踪的部署。ID 为fbaa7582的第一个部署是在你创建应用程序时发生的初始部署。ID 为ac5d6f39的第二个部署是在对index.php进行更改后发生的部署。

步骤 7 涉及使用rhc deployment-activate命令将代码回滚到 ID 为fbaa7582的部署。在幕后，rhc deployment-activate命令在应用程序 gear 上运行ssh <application_ssh_url> 'gear activate --all fbaa7582'命令来激活该部署。

最后，在步骤 8 中，你运行了rhc deployment-list命令来查看在步骤 7 中发生的回滚信息。

还有更多…

你还可以在应用程序创建过程中启用部署跟踪，方法如下：

$ rhc create-app myapp php-5.4 --keep-deployments 10

你还可以使用rhc show-app命令查看应用程序的配置信息：

$ rhc show-app --app myapp --configuration
myapp @ http://myapp-osbook.rhcloud.com/ (uuid: 52f78c895973ca4cbc000113)
-------------------------------------------------------------------------
 Deployment:        auto (on git push)
 Keep Deployments:  10
 Deployment Type:   git
 Deployment Branch: master

另见

使用 rhc 命令行客户端创建 OpenShift 应用程序教程
应用程序备份与恢复教程

配置默认的 Git 分支用于部署

每个 OpenShift 应用程序都有一个关联的远程 Git 仓库。当你使用git push将源代码推送到应用程序 gear 时，你实际上是将源代码推送到名为origin的 Git 远程仓库，并且分支是master。每个应用程序都配置为在将代码推送到远程 origin 上的 master 分支时自动部署。但是，有时你可能希望使用 master 分支进行开发，而使用生产分支进行部署。在本教程中，你将学习如何配置一个 OpenShift 应用程序，在该应用程序中，你将使用名为production的分支进行部署，使用master分支进行开发。

准备就绪

为了完成此教程，你需要在机器上安装 rhc。同时，你还需要使用使用 rhc 命令行客户端创建 OpenShift 应用程序这篇教程中创建的 OpenShift 应用程序。

如何操作…

执行以下步骤以配置不同的分支用于部署：

打开命令行终端，并将目录更改为myapp应用程序所在的位置。
使用 Git 命令行客户端创建一个名为production的新分支：
```
$ git branch production
```
配置myapp OpenShift 应用程序使用production分支进行部署：
```
$ rhc configure-app --deployment-branch production
```
打开应用程序目录中的index.php文件，并将头部更改为以下内容：
```
<h1>
Configured the 'production' branch for auto-deployment
</h1>
```
提交更改到本地仓库，然后将更改推送到主分支。由于我们已配置应用程序在部署生产分支时进行部署，所以只会推送代码，因此不会触发自动部署：
```
$ git commit -am "updated index.php"
$ git push
```
接下来，检出生产分支，并合并主分支的更改：
```
$ git checkout production
$ git merge master
```
现在，推送更改到应用程序 gear，变更将被部署：
```
$ git push origin production
```
现在，如果你访问http://myapp-{domain-name}.rhcloud.com，你将看到在第 4 步中所做的更改。

它是如何工作的……

OpenShift 利用 Git 动作钩子进行应用程序部署。默认情况下，每次将源代码推送到主分支时，都会发生部署。在第 1 步中，你将目录更改为myapp应用程序所在的位置。第 2 步帮助你创建了一个名为production的新分支用于将来的部署。你可以使用git branch命令列出 Git 仓库中的所有分支：

$ git branch
* master
 production

在第 3 步中，你配置了应用程序使用生产分支进行应用程序部署。命令成功完成后，你将看到以下输出：

Configuring application 'myapp' ... done
myapp @ http://myapp-osbook.rhcloud.com/ (uuid: 52f78c895973ca4cbc000113)
-------------------------------------------------------------------------
 Deployment:        auto (on git push)
 Keep Deployments:  10
 Deployment Type:   git
 Deployment Branch: production

Your application 'myapp' is now configured as listed above.

输出显示部署分支已更改为production。

在第 4 步中，你更改了index.php，并在第 5 步中提交并推送了更改到主分支。你会注意到，git push命令只将数据推送到应用程序的 gear 上，但不会触发部署。应用程序部署不会发生，因为在第 3 步中，你已配置应用程序在推送到生产分支时进行部署。git push命令的输出如下：

Counting objects: 7, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (4/4), done.
Writing objects: 100% (4/4), 427 bytes, done.
Total 4 (delta 2), reused 0 (delta 0)
To ssh://52f78c895973ca4cbc000113@myapp-osbook.rhcloud.com/~/git/myapp.git/
 8252402..9e4ac48  master -> master

在第 6 步中，你检出了生产分支，并合并了在主分支中所做的更改。你在第 7 步中将更改推送到生产分支，这将触发自动部署，变更将被部署到应用程序。git push origin production命令如下所示：

$ git push origin production
Total 0 (delta 0), reused 0 (delta 0)
remote: Stopping PHP 5.4 cartridge (Apache+mod_php)
remote: Waiting for stop to finish
remote: Building git ref 'production', commit 9e4ac48
remote: Checking deplist.txt for PEAR dependency..
remote: Preparing build for deployment
remote: Deployment id is 8c2a41a8
remote: Activating deployment
remote: Starting PHP 5.4 cartridge (Apache+mod_php)
remote: -------------------------
remote: Git Post-Receive Result: success
remote: Activation status: success
remote: Deployment completed with status: success
To ssh://52f78c895973ca4cbc000113@myapp-osbook.rhcloud.com/~/git/myapp.git/
 * [new branch]      production -> production

最后，你通过访问应用程序确认更改已经被部署。

还有更多……

如果你想完全关闭自动部署，也就是说，如果你即使在生产分支上也不想进行部署，可以使用--no-auto-deploy选项来实现：

$ rhc configure-app --app myapp --no-auto-deploy

这将关闭自动部署，且只会将代码推送到托管在应用程序 gear 上的 Git 仓库。如果你想部署代码，你必须手动部署，如手动部署食谱所示。

另见

使用 rhc 命令行客户端创建 OpenShift 应用程序食谱
跟踪和回滚应用程序部署食谱
进行手动部署食谱

进行手动部署

在为部署配置默认 Git 分支食谱中的更多...部分，我们查看了如何使用--no-auto-deploy选项通过rhc app-configure命令关闭自动部署。如果你关闭了自动部署，想要部署应用程序该怎么办？一种解决方案是通过运行rhc app-configure –auto-deploy命令重新配置应用程序以进行自动部署。如果你希望从现在起进行自动部署，这个解决方案很好，但如果你想自己管理部署，--auto-deploy选项就不是一个解决方案。在这个食谱中，你将学习如何手动将应用程序部署到 OpenShift。

做好准备

要完成这个食谱，你需要在你的机器上安装 rhc。此外，你还需要在使用 rhc 命令行客户端创建 OpenShift 应用程序食谱中创建的应用程序。

如何操作……

执行以下步骤进行手动部署：

打开命令行终端并将目录更改为myapp应用程序。
使用带有--no-auto-deploy选项的rhc configure-app命令禁用应用程序的自动部署：
```
$ rhc configure-app --app myapp --no-auto-deploy
```

对应用程序的index.php进行更改：

<h1>
Application configured with no-auto-deploy
</h1>

提交更改并将其推送到应用程序插槽。由于禁用了自动部署，代码不会被部署：
```
$ git commit –am "updated index.php"
$ git push
```
若要手动部署更改，请使用rhc deploy命令部署主分支：
```
$ rhc deploy --app --ref master
```
访问http://myapp-{domain-name}.rhcloud.com来查看更改。

它是如何工作的……

在第 1 步中，你将目录更改为myapp应用程序的位置。为了禁用自动部署，你使用了带有--no-auto-deploy选项的rhc configure-app命令。你可以通过运行带有--configuration选项的rhc show-app命令来查看应用程序的详细信息：

$ rhc show-app --configuration 
myapp @ http://myapp-osbook.rhcloud.com/ (uuid: 52f78c895973ca4cbc000113)
-------------------------------------------------------------------------
 Deployment:        manual (use 'rhc deploy')
 Keep Deployments:  10
 Deployment Type:   git
 Deployment Branch: master

如前一个命令所示，部署已设置为手动。在步骤 3 和 4 中，你在index.php中进行了更改，然后提交并推送更改到应用程序插槽。由于我们在第 2 步中禁用了自动部署，自动部署不会启动。git push命令的输出如下所示：

$ git push
Counting objects: 7, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (4/4), done.
Writing objects: 100% (4/4), 421 bytes, done.
Total 4 (delta 2), reused 0 (delta 0)
To ssh://52f78c895973ca4cbc000113@myapp-osbook.rhcloud.com/~/git/myapp.git/
 9e4ac48..75ea3dc  master -> master

在第 5 步中，你使用rhc deploy命令手动部署了更改。rhc deploy命令需要一个引用，可以是 Git 标签、Git 提交 ID 或 Git 分支名称。此步骤使用了主分支进行部署。rhc deploy命令在底层执行了gear deploy master命令。第 5 步的输出如下所示：

$ rhc deploy --ref master
Deployment of git ref 'master' in progress for application myapp ...
Stopping PHP 5.4 cartridge (Apache+mod_php)
Waiting for stop to finish
Building git ref 'master', commit 75ea3dc
Checking deplist.txt for PEAR dependency..
Preparing build for deployment
Deployment id is c36cde4a
Activating deployment
Starting PHP 5.4 cartridge (Apache+mod_php)
Success

如前一个命令所示，首先停止了插槽，然后使用 Git 主分支的最新提交 ID 构建应用程序，最后部署更改。

最后，你可以查看已部署的应用程序并验证更改是否已部署。

还有更多……

除了使用分支名称，您还可以在 rhc deploy 命令中使用 Git 提交 ID 或 Git 标签。您可以查看如何在 rhc deploy 命令中使用提交 ID：

$ rhc deploy --ref 9e4ac482d87fdbcf82546afb5a58910be0b9ef19

另请参见

使用 rhc 命令行客户端创建 OpenShift 应用程序 配方
查看应用程序详情 配方

配置和执行二进制部署

到目前为止，我们已经了解了如何在 OpenShift 中轻松执行基于 Git 的部署，您只需执行 git push 命令，OpenShift 会构建并部署应用程序。如果您想执行基于源代码的部署，这非常理想。可能您希望 OpenShift 也通过 Git 来管理您的源代码。但有些情况下，开发人员不希望将源代码推送到 OpenShift 服务器。在这种情况下，您可以使用二进制部署来部署二进制工件。当您希望部署二进制工件（如 .war 文件）时，这种方法特别理想，因为 Git 并不是存储二进制文件的高效方式。

准备就绪

要执行本教程，您需要在机器上安装 rhc。

如何操作…

执行以下步骤进行二进制部署：

打开命令行终端，切换到适当的位置。然后，使用 rhc 创建一个新的 JBoss EAP 6 应用程序，如下所示的命令。注意，我们使用了 --no-git 选项，因为我们不想使用 Git：
```
$ rhc create-app javaapp jbosseap --no-git
```
配置应用程序使用二进制部署。同时，关闭自动部署，并配置应用程序存储两个部署版本。这将有助于我们以后回滚到先前的版本。请查看以下命令：
```
$ rhc configure-app --app javaapp --no-auto-deploy --keep-deployments 2 --deployment-type binary
```

创建一个目录结构，如下所示的命令：

$ mkdir javaapp-binary-deployment
$ cd javaapp-binary-deployment/
$ mkdir -p build-dependencies/.m2 repo/deployments dependencies/jbosseap/deployments

下载或复制 WAR 文件到 repo/deployments 文件夹：

$ cd repo/deployments
$ wget https://github.com/OpenShift-Cookbook/chapter3-recipe15/raw/master/ROOT.war --no check-certificate

将文件夹结构打包成归档文件。您可以使用 ZIP、TAR、tar.gz 或 tar.bz 格式：
```
$ cd ../../
$ tar -czvf ../javaapp-archive.tar.gz ./
```

使用 rhc deploy 命令部署新的二进制工件：

rhc deploy --app javaapp --ref ../javaapp-archive.tar.gz

如何工作…

在第 1 步中，您创建了一个名为 javaapp 的 JBoss EAP 6 应用程序。您还使用了 --no-git 选项与 rhc app-create 命令，因为我们不希望将 Git 仓库克隆到本地机器。接下来，在第 2 步中，您配置了应用程序使用二进制部署。OpenShift 支持两种部署类型——Git 和二进制。Git 部署类型是默认的部署类型，通过 git push 命令触发。当您使用此方式时，系统会构建一个部署工件，并将其部署到服务器上。

使用二进制部署类型时，您需要提供部署归档文件，因为 OpenShift 环境不会负责构建部署。二进制部署需要一个符合指定目录格式的归档文件。在步骤 3 中，您创建了一个特定于 JBoss EAP 6 应用程序类型的目录结构。请查看以下命令：

$ tree -a
.
├── build-dependencies
│   └── .m2
├── dependencies
│   └── jbosseap
│       └── deployments
└── repo
 └── deployments

7 directories, 0 files

由于我们正在执行二进制部署，你刚刚将 WAR 文件下载到了 repo/deployments 文件夹。接下来，在第 5 步，你创建了一个带有仓库结构的 tar.gz 存档。最后，在第 6 步，你使用 rhc deploy 命令部署了二进制构件。你也可以使用 HTTP URL 来代替本地文件路径，如以下代码所示：

$ rhc deploy --app javaapp --ref https://github.com/OpenShift-Cookbook/chapter3-recipe15/raw/master/javaapp-archive.tar.gz

还有更多…

你可以随时使用 rhc snapshot-save 命令保存一个部署快照：

$ rhc snapshot-save --app javaapp --deployment

这将把一个 javaapp.tar.gz 存档保存到本地计算机。然后，你可以随时使用 rhc deploy 命令部署这个构件。

另请参见

使用 rhc 命令行客户端创建 OpenShift 应用程序 配方
查看应用程序详细信息 配方

使用你自己的自定义域名

默认情况下，OpenShift 创建的所有应用程序都是 rhcloud.com 的子域。在本配方中，你将学习如何将自己创建的 myapp 应用程序与 使用 rhc 命令行客户端创建 OpenShift 应用程序 配方中的自定义域名结合使用。

准备工作

要完成本配方，你需要在机器上安装 rhc。同时，我们将使用 使用 rhc 命令行客户端创建 OpenShift 应用程序 配方中创建的 OpenShift 应用程序。

如何操作…

第一步是从域名注册提供商处购买一个域名。我将使用 GoDaddy，因为我在那有一些域名，但你也可以选择其他域名提供商。我已购买了 openshift-cookbook.in 域名用于此次演示。
打开你的域名注册提供商的 DNS 管理控制台，添加一个 CNAME 记录。CNAME 记录允许你将一个域名指向另一个域名。你可以创建一个新的 CNAME 记录，将其指向 www.subdomain to myapp-osbook.rhcloud.com，如下图所示：
在创建 CNAME 记录后，你需要将 OpenShift 应用程序与自定义名称关联。这是通过 rhc alias 命令完成的。要为 www.openshift-cookbook.in 创建别名，请运行以下命令。请使用你自己的域名与 rhc alias 命令。请看以下命令：
```
$ rhc alias-add --app myapp www.openshift-cookbook.in
```

它是如何工作的…

在第 2 步，你为 www 子域创建了一个新的 CNAME 条目。OpenShift 通过将 规范名称 (CNAME) 条目指向你的 DNS 提供商的设置来允许你这样做，从而为你的域名提供别名。CNAME 指定该域名是另一个域名的别名。在前面的示例中，www.openshift-cookbook.com 成为 http://myapp-osbook.rhcloud.com 的别名。在第 3 步，你运行了 rhc alias 命令，允许你使用自己的域名来运行应用程序。从技术上讲，OpenShift 在后台所做的工作是设置了 Apache 中的 Vhost 来处理 URL。

现在，如果你访问你的自定义域名，比如http://www.openshift-cookbook.in，你将看到你的 OpenShift 应用程序首页。

如果使用www子域，这个配置可以正常工作，但如果从openshift-cookbook.in的 URL 中去除www，则无法正常工作。开发人员通常需要同时支持根域和www域名。为了让它正常工作，你必须使用域名转发，这样当请求到达openshift-cookbook.in时，它会被转发到www.openshift-cookbook.in。打开 DNS 提供商的 Web 控制台并进入转发标签。将请求从openshift-cookbook.in转发到http://www.openshift-cookbook.in，如下所示：

反映转发更改大约需要 30 分钟。更改传播后，访问openshift-cookbook.in，你将被重定向到http://www.openshift-cookbook.in。

还有更多…

你也可以使用 OpenShift Web 控制台设置别名。有关更多信息，请参考 OpenShift 博客：www.openshift.com/blogs/how-to-configure-custom-domain-names-and-ssl-in-the-openshift-web-console。

另见

使用 rhc 命令行客户端创建 OpenShift 应用程序食谱
查看应用程序详情食谱

清理应用程序

当你开始使用 OpenShift 进行应用程序开发时，构成应用程序的不同组件，如 Git 和 cartridge 日志目录，将开始消耗磁盘空间。在 OpenShift Online 免费套餐中，应用程序仅分配 1 GB 的磁盘空间，因此有效利用磁盘空间变得至关重要，以避免磁盘配额错误。在这个食谱中，你将学习如何定期清理你的应用程序，以避免磁盘配额错误。

准备就绪

要执行此步骤，你需要在机器上安装 rhc。同时，我们将使用使用 rhc 命令行客户端创建 OpenShift 应用程序中的 OpenShift 应用程序。

如何操作…

要清理应用程序，请打开命令行终端并运行以下命令：

$ rhc tidy-app --app myapp

它是如何工作的…

rhc tidy-app命令有助于管理应用程序的磁盘空间。底层执行了三个操作：

首先，rhc tidy-app命令停止应用程序。
接下来，它会清除应用程序的tmp目录。tmp目录的位置可以通过获取OPENSHIFT_TMP_DIR环境变量找到。
接下来，它会清除每个 cartridge 的日志目录。
然后，它清理服务器上的应用程序 Git 仓库。使用两个 Git 命令完成 Git 仓库清理：git prune命令从 Git 仓库对象数据库中删除所有不可访问的对象。git gc --aggressive命令删除任何松散的对象，并压缩对象以更有效地使用磁盘空间。
最后，它启动应用程序。即使rhc tidy命令出现任何异常，应用程序也会启动。

还有更多内容…

您还可以创建一个每日或每周运行git gc的定时任务，以定期处理应用程序的工作载荷。为此，请将定时任务插件添加到应用程序中。参考将定时任务插件添加到应用程序说明。在添加插件后，在.openshift/cron/daily目录下创建一个名为gc_cleanup.sh的新 shell 脚本，并将以下内容添加到其中：

#!/bin/bash
cd ~/git/$OPENSHIFT_APP_NAME.git
git prune
git gc --aggressive
echo "Ran Git cleanup at $(date)">> $OPENSHIFT_REPO_DIR/php/git-gc.txt

提交文件并将其推送到应用程序工作载荷。每天的定时任务将执行 Git 清理操作。

另请参阅

使用 rhc 命令行客户端创建 OpenShift 应用程序说明
查看应用程序详细信息说明

删除应用程序

在此说明中，您将学习如何删除 OpenShift 应用程序。

准备工作

要按照此步骤进行操作，您需要在您的计算机上安装 rhc。此外，您将使用使用 rhc 命令行客户端创建 OpenShift 应用程序说明中创建的应用程序。

如何操作…

要删除一个应用程序，请打开命令行终端并运行以下命令：

$ rhc delete-app --app myapp --confirm

工作原理…

rhc -delete命令会删除应用程序及其在 OpenShift 服务器上的所有数据。您无法撤销此命令，因此请谨慎使用。在幕后，rhc -delete命令会发送 HTTP DELETE 请求以删除应用程序。

另请参阅

使用 rhc 命令行客户端创建 OpenShift 应用程序说明
查看应用程序详细信息说明

第四章. 在 OpenShift 应用程序中使用 MySQL

本章展示了一些教程，向你展示如何开始使用 OpenShift MySQL 数据库卡带。你将学习如何添加和管理 MySQL 卡带，如何进行 MySQL 数据库备份，以及如何在 OpenShift 应用程序中使用 Amazon RDS MySQL 支持。本章中的具体教程包括：

向应用程序添加 MySQL 卡带
向应用程序添加 phpMyAdmin 卡带
从本地机器访问 MySQL 数据库
使用 MySQL Workbench 从本地机器连接到 MySQL 卡带
更新 MySQL 最大连接数设置
更新 MySQL 配置设置
执行定期的 MySQL 数据库备份
使用 Amazon RDS MySQL 数据库实例与 OpenShift 配合使用

介绍

每个典型的 Web 应用程序都需要某种形式的持久数据存储在后台。OpenShift 支持多种存储选项，包括几个第三方提供商，这些提供商解放你免于处理硬件配置和数据库管理。在编写本书时，OpenShift 官方支持 MySQL、PostgreSQL 和 MongoDB 数据存储。除了这些受支持的数据库，还有可供下载的第三方数据库卡带，如 Redis 和 MariaDB。Red Hat 不支持这些可下载的卡带，因此你需要自行承担使用风险。本章将详细介绍 MySQL 卡带。第五章，在 OpenShift 应用程序中使用 PostgreSQL，以及第六章，在 OpenShift 应用程序中使用 MongoDB 和第三方数据库卡带，将分别介绍 PostgreSQL 和 MongoDB 卡带。

本章将使用我们在第三章，创建与管理应用程序中创建的 PHP 5.4 应用程序。如果你没有运行任何 OpenShift 应用程序，可以通过运行以下命令创建一个新的 OpenShift 应用程序：

$ rhc create-app myapp php-5.4

在前面的命令中，我们创建了一个不可扩展的应用程序，因为我们没有使用–s选项。如果应用程序是不可扩展的，则数据库卡带安装在与主应用程序卡带相同的设备上。如果你创建了一个可扩展的应用程序，则数据库卡带将安装在其专用设备上。这使得数据库可以使用所有可用的 RAM 和磁盘空间。我们将在第十一章中讨论可扩展的应用程序，记录与扩展你的 OpenShift 应用程序。

OpenShift 还提供了一个持久化数据目录来存储您的数据。该持久化数据目录不可扩展，因此不应与可扩展应用程序一起使用。对于可扩展应用程序，您应该使用像 Amazon S3 这样的第三方服务。

OpenShift 支持标准化的、经过安全加固的 MySQL、PostgreSQL 和 MongoDB 数据库版本。如果出现问题，OpenShift 运维团队可帮助解决操作问题。而且，由于您使用的是标准版本的数据库，您不会被 OpenShift 锁定，如果需要，您可以轻松迁移数据。在本章中，我们将介绍如何定期备份数据库插件，以确保在出现问题时您始终可以保留数据。

如果在 OpenShift 中运行数据库不可行，或者您已经投资了第三方服务，您还可以使用第三方数据库服务，如 Amazon RDS。另一个您可能选择使用第三方数据库服务的原因是，OpenShift 的数据库插件不具备可扩展性。因此，对于需要水平可扩展、高可用数据库的应用程序，您可以使用本章涵盖的任何第三方数据库服务。本章将介绍如何将 Amazon RDS 与 OpenShift 应用程序结合使用。第五章 与 OpenShift 应用程序一起使用 PostgreSQL 和第六章 与 OpenShift 应用程序一起使用 MongoDB 和第三方数据库插件 将介绍第三方 PostgreSQL 和 MongoDB 云数据库服务。

将 MySQL 插件添加到您的应用程序中

在写作本文时，OpenShift 支持两种版本的 MySQL 数据库。您可以通过运行以下命令查看支持的 MySQL 版本：

$ rhc cartridges|grep mysql
mysql-5.1           MySQL 5.1                               addon
mysql-5.5           MySQL 5.5                               addon

准备工作

为了准备本操作，您需要在机器上安装 rhc 命令行客户端。请参阅第一章 安装 OpenShift rhc 命令行客户端 章节，获取更多详细信息。此外，我们将在第三章 使用 rhc 命令行客户端创建 OpenShift 应用程序 章节中使用创建的应用程序。

如何操作…

按照以下步骤将 MySQL 数据库插件添加到您的 OpenShift 应用程序并进行管理：

要将 MySQL 5.5 插件添加到 myapp 应用程序中，打开一个新的命令行终端，将目录切换到 myapp 目录位置，并执行以下命令：
```
$ rhc add-cartridge -c mysql-5.5 --app myapp
```
这将会在你的应用程序 gear 上安装一个新的 MySQL 数据库实例。-c 选项用于指定 Cartridge 名称，--app 选项用于指定应用程序名称。如果你从应用程序目录中运行命令，则 --app 选项不是必需的。-c 选项是必需的，但你可以省略 -c，因为 rhc 命令行客户端足够智能，可以推断出 mysql-5.5 是 Cartridge 名称。以下命令可以看出：
```
$ rhc cartridge-add mysql-5.5
```

你可以使用 rhc show-cartridge 命令查看 Cartridge 详情，如下命令行所示：

$ rhc show-cartridge mysql
Using mysql-5.5 (MySQL 5.5) for 'mysql'
mysql-5.5 (MySQL 5.5)
---------------------
 Gears:          Located with php-5.4
 Connection URL: mysql://$OPENSHIFT_MYSQL_DB_HOST:$OPENSHIFT_MYSQL_DB_PORT/
 Database Name:  myapp
 Password:       lQkran3E1a4K
 Username:       adminjL3VBAM

要停止 MySQL 数据库 Cartridge，请使用如下命令中的 stop 命令：
```
$ rhc stop-cartridge mysql
```
要重新启动 MySQL 数据库 Cartridge，请使用如下命令中的 restart 命令：
```
$ rhc restart-cartridge mysql
```
最后，如果你想从应用程序中删除 MySQL 数据库，可以使用如下命令中的 remove 命令：
```
$ rhc remove-cartridge mysql --confirm
```

它是如何工作的…

当你运行 rhc cartridge-add 命令时，rhc 会向 OpenShift 服务器发送一个 HTTP POST 请求。OpenShift 服务器接收请求后，会为你的应用程序实例化一个新的 MySQL 服务器。MySQL 服务器配置完成后，rhc 客户端会在命令行终端显示数据库详情，如下所示：

Adding mysql-5.5 to application 'myapp' ... done

mysql-5.5 (MySQL 5.5)
---------------------
 Gears:          Located with php-5.4
 Connection URL: mysql://$OPENSHIFT_MYSQL_DB_HOST:$OPENSHIFT_MYSQL_DB_PORT/
 Database Name:  myapp
 Password:       lQkran3E1a4K
 Username:       adminjL3VBAM

MySQL 5.5 database added.  Please make note of these credentials:

 Root User: adminjL3VBAM
 Root Password: lQkran3E1a4K
 Database Name: myapp

Connection URL: mysql://$OPENSHIFT_MYSQL_DB_HOST:$OPENSHIFT_MYSQL_DB_PORT/

你可以通过 SSH 登录到你的应用程序 gear 来查看 MySQL 安装：

$ rhc ssh --app myapp

然后运行 ls 命令查看 gear 目录结构：

[myapp-osbook.rhcloud.com 52fb71aa5973caf609000026]\> ls -p
app-deployments/  app-root/  git/  mysql/  php/

mysql 目录托管了你的 mysql 安装。MySQL 数据库不与任何其他 OpenShift 应用程序或用户共享。它仅供你的应用程序使用，只有你的应用程序可以访问它。

你可以使用 mysql 命令行客户端连接到 mysql 目录并访问你的 MySQL 数据库，如下命令所示：

[myapp-osbook.rhcloud.com 52fb71aa5973caf609000026]\> mysql
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 3
Server version: 5.5.32 MySQL Community Server (GPL)

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>

现在，你可以对 MySQL 服务器运行 SQL 命令。要查看所有数据库，运行以下命令：

mysql> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| myapp              |
| mysql              |
| performance_schema |
+--------------------+
4 rows in set (0.00 sec)

myapp 数据库对应于你的应用程序数据库。你可以使用此数据库为你的应用程序服务，或者使用 CREATE DATABASE 命令创建一个新数据库。要查看 MySQL 数据库的运行时间，尝试运行以下命令：

mysql> SHOW STATUS LIKE 'Uptime';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| Uptime        | 2573  |
+---------------+-------+
1 row in set (0.00 sec)

输出显示 MySQL 服务器已启动 2573 秒。

你可以通过输入 mysql 并按两次 Tab 键，查看 gear 上所有可用的 MySQL 命令行工具：

[myapp-osbook.rhcloud.com 52fb71aa5973caf609000026]\> mysql
mysql                       mysql_convert_table_format  mysql_fix_privilege_tables  mysqlslap
mysqlaccess                 mysqld_multi                mysqlhotcopy  mysqltest
mysqladmin                  mysqld_safe                 mysqlimport   mysql_tzinfo_to_sql
mysqlbinlog                 mysqldump                   mysql_install_db            mysql_upgrade
mysqlbug                    mysqldumpslow               mysql_secure_installation   mysql_waitpid
mysqlcheck                  mysql_find_rows             mysql_setpermission         mysql_zap
mysql_config                mysql_fix_extensions        mysqlshow

还有更多…

你还可以通过 OpenShift Web 控制台添加 MySQL Cartridge。访问 openshift.redhat.com/app/console/applications，然后点击 myapp 应用程序以查看详情。在 myapp 应用程序详情页面上，你将看到添加 MySQL 数据库的选项，如下图所示。点击 Add MySQL 5.5 链接以添加 MySQL 5.5 Cartridge。

接下来，点击 Add Cartridge 按钮，将 MySQL 5.5 Cartridge 添加到你的应用程序中，如下图所示：

安装 MySQL 卡带后，您将看到以下 MySQL 数据库详细信息：

另请参见

第三章中的 使用 rhc 命令行客户端创建 OpenShift 应用程序 配方，创建与管理应用程序
将 phpMyAdmin 卡带添加到您的应用程序 配方
从本地机器访问 MySQL 数据库的配方

将 phpMyAdmin 卡带添加到您的应用程序

phpMyAdmin（您可以访问 www.phpmyadmin.net/）是一个免费的开源工具，使用 PHP 编程语言编写，旨在通过 Web 浏览器管理 MySQL 数据库。在本配方中，您将学习如何将 phpMyAdmin 卡带安装到您的应用程序中。

准备工作

要完成此配方，您需要一个带有 MySQL 卡带的应用程序。请参考本章中的 将 MySQL 卡带添加到您的应用程序 配方，了解如何添加 MySQL 卡带。

如何操作…

本配方将引导您完成将 phpMyAdmin 卡带添加到 OpenShift 应用程序所需的所有步骤：

要将 phpMyAdmin 卡带安装到 myapp 应用程序，请打开一个新的命令行终端，切换到 myapp 目录位置，然后执行以下命令：
```
$ rhc add-cartridge phpmyadmin-4
```
注意 rhc add-cartridge 命令返回的用户名和密码。您将需要这些凭据才能登录到 phpMyAdmin。phpMyAdmin 的凭据与 MySQL 数据库的凭据相同，您可以随时通过执行 rhc show-app 命令查看它们。
使用步骤 1 中获得的凭据登录到 phpMyAdmin，网址为 https://myapp-{domain-name}.rhcloud.com/phpmyadmin/。

它是如何工作的…

当您运行 rhc cartridge-add 命令时，rhc 客户端会向 OpenShift 服务器发出 HTTP POST 请求。OpenShift 服务器接收到请求后，会在应用程序硬件上安装 phpMyAdmin 卡带。phpMyAdmin 卡带适用于所有支持的应用程序类型（Java、Python、Node.js、Ruby、Perl 和 PHP）。您无需创建 PHP 应用程序即可使用 phpMyAdmin 卡带。OpenShift 将启动一个 Apache 进程来运行 phpMyAdmin 应用程序。

注意

只有在将 MySQL 卡带添加到应用程序后，您才能添加 phpMyAdmin 卡带。如果在添加 MySQL 卡带之前尝试添加 phpMyAdmin 卡带，您将遇到错误，Cartridge 'phpmyadmin-4' cannot be added without mysql。依赖项 mysql 可以通过 mysql-5.5 或 mysql-5.1 来满足。

还有更多内容…

您还可以从 OpenShift Web 控制台添加 phpMyAdmin 卡带。请访问 openshift.redhat.com/app/console/applications，并添加 phpMyAdmin 卡带。

另请参见

将 MySQL 卡带添加到您的应用程序 配方
从本地计算机访问 MySQL 数据库配方

从本地计算机访问 MySQL 数据库

在本章的将 MySQL 载体添加到您的应用程序配方中，您学会了通过在应用程序齿轮上执行 SSH 来访问 MySQL 数据库。在此配方中，您将学习如何从本地计算机连接到 MySQL 数据库。

准备工作

要完成此配方，您需要一个带有 MySQL 载体的应用程序。请参阅将 MySQL 载体添加到您的应用程序配方，了解如何安装 MySQL 载体。此外，您需要在您的计算机上安装mysql命令行客户端。您可以从官方网站dev.mysql.com/downloads/mysql/下载包含mysql命令行客户端的 MySQL 社区服务器。

如何做到…

按照以下步骤从本地计算机访问 MySQL 载体：

打开命令行终端，并将目录更改为myapp应用程序目录。执行以下命令将远程端口转发到本地计算机：
```
$ rhc port-forward --app myapp
```

上述命令的输出将列出您可以从本地计算机连接的端口及其服务。输出如下：

Service Local               OpenShift
------- -------------- ---- -------------------
httpd   127.0.0.1:8080  =>  127.12.123.129:8080
mysql   127.0.0.1:3306  =>  127.12.123.130:3306
Press CTRL-C to terminate port forwarding

按照以下命令从本地mysql命令行客户端连接到 MySQL 服务器。您可以使用rhc show-app或rhc cartridge-show mysql命令获取 MySQL 载体的用户名和密码。主机名和端口在rhc port-forward命令的输出中可用。
```
$ mysql --user=<user> --password=<password> --host 127.0.0.1 --port 3306
```

连接到 MySQL 服务器后，您可以按如下方式运行任何有效的 SQL 命令：

mysql> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| myapp              |
| mysql              |
| performance_schema |
+--------------------+
4 rows in set (0.38 sec)

工作原理…

在步骤 1 中，您使用rhc port-forward命令将所有远程端口转发到本地计算机。rhc port-forward命令是 SSH 端口的包装器。转发使得远程计算机上的端口在本地计算机上可用。远程计算机上本来无法访问的端口，您可以像访问本地计算机上的端口一样使用。以下命令返回您可以从本地计算机连接的端口列表：

$ rhc port-forward --app myapp
Checking available ports ... done
Forwarding ports ...

To connect to a service running on OpenShift, use the Local address

Service Local               OpenShift
------- -------------- ---- ------------------
httpd   127.0.0.1:8080  =>  127.9.255.129:8080
mysql   127.0.0.1:3306  =>  127.9.255.130:3306

Press CTRL-C to terminate port forwarding

正如您从上述输出中看到的，MySQL 进程在127.0.0.1主机的端口3306上可用。

在步骤 2 中，您从本地计算机连接到 MySQL 服务器，传入数据库的用户名、密码、主机和端口。连接成功后，在步骤 3 中运行了一个 SQL 命令。

要终止端口转发，请在运行rhc port-forward命令的命令行终端上按下Ctrl + C。

参见

将 MySQL 载体添加到您的应用程序配方
使用 MySQL Workbench 从本地计算机连接到 MySQL 载体配方

使用 MySQL Workbench 从本地计算机连接到 MySQL 载体

在从本地机器访问 MySQL 数据库配方中，我们向你展示了如何通过本地机器使用端口转发，从mysql命令行连接到 MySQL 数据库。在本配方中，你将学习如何通过 MySQL Workbench 连接到 MySQL 数据库。MySQL Workbench 是一个可视化的数据库设计工具，将 SQL 开发、管理、数据库设计、创建和维护集成到一个统一的开发环境中，用于 MySQL 数据库系统。

准备工作

完成此配方，你需要一个带有 MySQL 插件的应用程序。请参考本章的将 MySQL 插件添加到你的应用程序配方，学习如何安装 MySQL 插件。此外，你还需要在本地机器上安装 MySQL Workbench。你可以从 MySQL 官方网站下载 MySQL Workbench：dev.mysql.com/downloads/tools/workbench/。

如何操作…

按照以下步骤，通过在本地机器上运行的 MySQL Workbench 连接到 MySQL 插件：

打开命令行终端，切换到myapp应用程序目录。执行以下命令将远程端口转发到本地机器：
```
$ rhc port-forward --app myapp
```
启动 MySQL Workbench 应用程序，你将看到以下截图。点击加号按钮添加一个新的 MySQL 连接。
通过输入 MySQL 数据库的详细信息设置新连接。你可以通过rhc show-app或rhc cartridge-show mysql命令获取 MySQL 插件的用户名和密码。主机名和端口可在rhc port-forward命令的输出中找到。以下截图显示了设置新连接页面：
接下来，点击测试连接按钮以测试连接。连接成功后，你将看到以下对话框，并显示消息连接参数正确：
通过点击确定按钮连接到 MySQL 插件。你将在 MySQL Workbench 界面上看到新的连接列表，点击该连接以打开 SQL 编辑器。
现在，你可以在 SQL 编辑器中运行任何合法的 SQL 查询，如下图所示：

它是如何工作的…

在步骤 1 中，你使用了rhc port-forward命令将所有远程端口转发到本地机器。这使得能够连接到你应用程序内运行的 MySQL 数据库。从步骤 2 到步骤 6，你创建了一个新的 MySQL 连接，并通过 MySQL Workbench 连接到 MySQL 插件。在步骤 7 中，你通过 SQL 编辑器执行了一个 SQL 查询，以检查该连接是否正在从安装在myapp应用程序中的 MySQL 插件获取数据。

另见

将 MySQL 插件添加到你的应用程序配方
从本地计算机访问 MySQL 数据库的配方

更新 MySQL 最大连接数设置

当所有可用连接都被其他客户端占用时，MySQL 数据库将开始产生过多的连接错误。在此配方中，您将学习如何更新 MySQL 卡带的最大连接数设置。

准备工作

要完成此配方，您需要一个带有 MySQL 卡带的应用程序。请参考本章的将 MySQL 卡带添加到你的应用程序配方，了解如何安装 MySQL 卡带。

如何做到…

按照以下步骤更新 MySQL 最大连接数设置：

要将最大连接数设置为200，请打开命令行终端，并运行以下命令：
```
$ rhc env-set OPENSHIFT_MYSQL_MAX_CONNECTIONS=200 --app myapp
```
设置环境变量后，必须使用以下命令重启 MySQL 卡带，才能使更改生效：
```
$ rhc cartridge-restart mysql --app myapp
```

它是如何工作的…

MySQL 数据库支持的连接数由 max_connections 系统变量控制。max_connections 的默认值是 151。您可以通过运行以下 SQL 查询来查看当前值。要查看 OpenShift 应用程序的 max_connections，请 SSH 进入应用程序 gear，并运行以下命令：

mysql> show variables like 'max_connections';
+-----------------+-------+
| Variable_name   | Value |
+-----------------+-------+
| max_connections | 151   |
+-----------------+-------+

配置 max_connections 系统变量的一种方法是在 my.cnf MySQL 配置文件中的 [mysqld] 部分添加 max_connections = 200。此方案在 OpenShift 中不起作用，因为 my.cnf 文件是只读的。为了允许用户更改 max_connections 值，OpenShift 提供了一个名为 OPENSHIFT_MYSQL_MAX_CONNECTIONS 的环境变量，可以用来设置 max_connections 系统变量。在第 1 步中，您将 OPENSHIFT_MYSQL_MAX_CONNECTIONS 环境变量设置为 200。MySQL 服务器不会读取新值，除非您重启数据库。因此，在第 2 步中，您通过 rhc cartridge-restart 命令重启了数据库。要验证 max_connections 值是否更新，您可以再次运行以下 SQL 命令：

mysql> show variables like 'max_connections';
+-----------------+-------+
| Variable_name   | Value |
+-----------------+-------+
| max_connections | 200   |
+-----------------+-------+

这是更新 MySQL max_connections 系统变量值的推荐方式。此方法的唯一缺点是您必须重启 MySQL 数据库，根据情况，这可能不是理想的方式。您还可以通过执行以下 SQL 命令来更新 max_connections 系统变量：

mysql> set global max_connections = 200;

这将立即生效，并且无需重启。但是，一旦 MySQL 数据库重启，此值将会丢失。

最佳方案是将两种方法结合起来。首先运行 set global max_connections = 200; SQL 命令，确保 max_connections 被即时更新，然后使用 rhc env-set 命令创建一个新的环境变量。这意味着下次启动 MySQL 数据库时，它将从环境变量中获取该值。

另请参见

将 MySQL 卡带添加到你的应用程序的配方
更新 MySQL 配置设置 配方

更新 MySQL 配置设置

MySQL 数据库将其配置设置存储在 my.cnf 文件中。该文件位于 MySQL 插件安装目录下的 conf 文件夹中。如前所述，OpenShift 不允许用户更新 my.cnf 配置文件。解决方法是使用一组环境变量来配置 MySQL 数据库的各种设置。

在撰写本书时，你可以通过环境变量配置以下 MySQL 设置：

MySQL 设置	OpenShift 环境变量
`lower_case_table_names`	`OPENSHIFT_MYSQL_LOWER_CASE_TABLE_NAMES`
`default-storage-engine`	`OPENSHIFT_MYSQL_DEFAULT_STORAGE_ENGINE`
`max_connections`	`OPENSHIFT_MYSQL_MAX_CONNECTIONS`
`ft_min_word_len`	`OPENSHIFT_MYSQL_FT_MIN_WORD_LEN`
`ft_max_word_len`	`OPENSHIFT_MYSQL_FT_MAX_WORD_LEN`
`innodb_use_native_aio`	`OPENSHIFT_MYSQL_AIO`
`default-time-zone`	`OPENSHIFT_MYSQL_TIMEZONE`
`table_open_cache`	`OPENSHIFT_MYSQL_TABLE_OPEN_CACHE`

准备工作

要完成这个配方，你需要一个包含 MySQL 插件的应用程序。请参考本章的 将 MySQL 插件添加到你的应用程序 配方，学习如何将 MySQL 插件添加到你的应用程序中。

如何操作…

按照以下步骤更新 MySQL 的 lower_case_table_names 配置：

要设置 lower_case_table_names 设置，你应该输入以下命令：

$ rhc env-set OPENSHIFT_MYSQL_LOWER_CASE_TABLE_NAMES=1 --app myapp

设置环境变量后，你需要使用以下命令重启 MySQL 插件，以使更改生效：
```
$ rhc cartridge-restart mysql --app myapp
```

它的工作原理…

它的工作原理是，OpenShift 提供了一组环境变量，你可以设置这些变量来配置 MySQL 的配置设置。在设置好环境变量后，你需要重启 MySQL 数据库，以便它能使用新的配置值。

另见

将 MySQL 插件添加到你的应用程序 配方
更新 MySQL 最大连接数设置 配方

执行定期 MySQL 数据库备份

在这个配方中，你将学习如何执行 MySQL 数据库的定期备份并将其上传到 Amazon S3。

准备工作

要完成这个配方，你需要一个包含 MySQL 插件的应用程序。请参考本章的 将 MySQL 插件添加到你的应用程序 配方，学习如何安装 MySQL 插件。另外，你需要一个 Amazon AWS 账户。访问 aws.amazon.com/，如果你还没有账户，请注册一个新的账户。

如何操作…

按照以下步骤设置 MySQL 插件的每日备份：

访问 console.aws.amazon.com/s3/home，并创建一个新的存储桶来存储你的数据库备份。
通过运行以下命令向你的应用程序添加一个 cron 插件：
```
$ rhc add-cartridge cron --app myapp
```

SSH 进入应用服务器，并在$OPENSHIFT_DATA_DIR下载s3-bash工具。然后，运行以下命令将其解压到s3-bash目录：

$ rhc ssh --app myapp
$ cd $OPENSHIFT_DATA_DIR
$ wget http://s3-bash.googlecode.com/files/s3-bash.0.02.tar.gz
$ mkdir s3-bash
$ tar -xf s3-bash.0.02.tar.gz -C s3-bash

在$OPENSHIFT_DATA_DIR/s3-bash目录中创建一个名为AWSSecretAccessKeyIdFile的新文件，并将你的 Amazon 访问密钥秘密存储其中。这是s3-bash与 Amazon S3 通信所必需的。

在你的本地机器上创建一个位于.openshift/cron/minutely的脚本，名为database_backup.sh，并将以下内容添加到该脚本中：

#!/bin/bash
if [ `date +%H:%M` == "23:50" ]
then
    FILE_NAME=$(date +"%Y%m%d%H%M")
    mysqldump --user $OPENSHIFT_MYSQL_DB_USERNAME -p$OPENSHIFT_MYSQL_DB_PASSWORD --host $OPENSHIFT_MYSQL_DB_HOST $BACKUP_DATABASE_NAME > $OPENSHIFT_DATA_DIR/$FILE_NAME.sql
    echo "Took MySQL Dump" >> $OPENSHIFT_CRON_DIR/log/backup.log
    $OPENSHIFT_DATA_DIR/s3-bash/s3-put -k $AWS_ACCESS_KEY_ID -s $OPENSHIFT_DATA_DIR/s3-bash/AWSSecretAccessKeyIdFile -T $OPENSHIFT_DATA_DIR/$FILE_NAME.sql /$AWS_S3_BUCKET/$FILE_NAME.sql
    echo "Uploaded dump to Amazon S3" >> $OPENSHIFT_CRON_DIR/log/backup.log
    rm -f $OPENSHIFT_DATA_DIR/$FILE_NAME.sql
fi

上述脚本将每天23:50运行，并执行mysqldump命令生成数据转储文件。然后，使用s3-bash API 将该文件传输到 Amazon S3。最后，上传文件后，它会从应用服务器删除 SQL 转储文件。

创建以下环境变量。请参考 Amazon EC2 文档，了解如何创建访问密钥和S3 桶的详细步骤。然后，运行以下命令：

$ rhc env-set AWS_ACCESS_KEY_ID=< Your Amazon ACCESS_KEY_ID>
$ rhc env-set BACKUP_DATABASE_NAME=<Database you want to take backup off>
$ rhc env-set AWS_S3_BUCKET=<Amazon S3 bucket name >

接下来，提交代码并将其推送到 OpenShift 应用服务器。该计划任务将在每晚23:50（11:50 pm）执行，以进行数据库备份，并将备份上传到 Amazon S3：
```
$ git commit –am "database backup script added"
$ git push
```

它是如何工作的……

在第 1 步中，你创建了一个新的 Amazon S3 桶来存储 MySQL 数据库备份。Amazon S3 被广泛用于存储静态文件，是进行此任务的理想选择。接下来，在第 2 步中，你为应用添加了cron插件。cron插件将用于在特定时间执行每日备份。

Amazon S3 提供其 REST 服务，用户可以使用这些服务对 S3 桶执行操作。Amazon 为多个编程语言提供了围绕其 REST API 的封装，方便开发者将其集成到应用中。为了保持本食谱的语言无关性，我们使用了 Amazon 的S3-bash包装器。尽管 Amazon 官方并不支持此包装器，但它仍然能够很好地工作。在第 3 步中，你使用wget工具下载了s3-bash包装器。tar.gz文件被存储在$OPENSHIFT_DATA_DIR中，然后你将其解压到s3-bash目录。

在第 4 步中，你创建了一个名为AWSSecretAccessKeyIdFile的文件来存储 Amazon 访问密钥的秘密。s3-bash包装器使用此文件来获取 AWS 的秘密访问密钥 ID，从而确保它不会出现在使用ps命令查看的运行进程列表中。

在第 5 步中，你创建了一个 bash 脚本，该脚本将在每晚 11:50 pm 执行。该脚本首先使用mysqldump命令进行数据库备份，然后将文件上传到 Amazon S3。文件名为当前的时间戳。最后，上传备份到 S3 后，脚本会删除备份文件以节省磁盘空间。如果你的 MySQL 数据库较大，可能希望压缩mysqldump的输出。你只需更新第 5 步中的mysqldump命令，使用以下命令所示的方式：

mysqldump --user $OPENSHIFT_MYSQL_DB_USERNAME -p$OPENSHIFT_MYSQL_DB_PASSWORD --host $OPENSHIFT_MYSQL_DB_HOST $BACKUP_DATABASE_NAME | gzip -9 > $OPENSHIFT_DATA_DIR/$FILE_NAME.gz

在上述命令中，我们使用了gzip，一种流行的数据压缩程序，来压缩mysqldump输出。

在第 6 步中，你创建了备份脚本所需的三个环境变量。最后，在第 7 步中，你提交了更改并将其推送到 OpenShift 应用程序配置。

另请参见

将 MySQL 卡片添加到你的应用程序配方

使用 Amazon RDS MySQL DB 实例与 OpenShift

Amazon 关系型数据库服务（Amazon RDS）是一个 Web 服务，它使你可以轻松地在 Amazon EC2 上设置、操作和扩展关系型数据库。它提供了对 MySQL、Oracle、PostgreSQL 和 Microsoft SQL Server 数据库引擎的访问。除了标准的数据库功能外，RDS 还提供以下功能：

自动数据库补丁
自动备份
时间点恢复
通过单个 API 调用进行数据库实例的垂直扩展

在本配方中，你将学习如何在 OpenShift 应用程序中使用 Amazon RDS MySQL 数据库服务。

准备工作

要完成此配方，你需要一个带有 MySQL 卡片的应用程序。请参考本章的将 MySQL 卡片添加到你的应用程序配方，学习如何安装 MySQL 卡片。另外，你需要有一个 Amazon AWS 账户。如果你还没有，请访问 aws.amazon.com/，并注册一个新账户。

如何操作…

按照以下步骤，了解如何在 OpenShift 应用程序中使用 Amazon RDS MySQL 数据库：

访问 console.aws.amazon.com/rds/home，然后点击安全组，如下面的截图所示：
点击创建 DB 安全组选项以创建一个新的安全组，然后在点击添加按钮之前，输入新安全组的详细信息（如下图所示）：
新的安全组将显示在安全组列表中。点击详情图标查看安全组详情。
接下来，配置安全组以允许来自所有 IP 的流量。输入 CIDR 值0.0.0.0/0后，点击添加按钮，如下图所示：
几秒钟后，新创建的 CIDR 连接类型将在安全组详情下显示：
点击左侧导航栏中的实例选项，然后点击启动 DB 实例：
接下来，你需要选择你想要使用的数据库引擎。选择使用 MySQL 数据库选项。
接下来，你需要选择是否将这个数据库用于生产还是开发目的。我们选择否，但对于生产环境，建议选择是。
然后，输入数据库的详细信息，包括 MySQL 版本、数据库标识符、用户名和连接 MySQL 数据库的密码等，具体内容如下图所示：
在附加配置页面，你需要提供 RDS 启动 MySQL 数据库所需的附加信息。你需要指定数据库名称、端口、可用区、数据库安全组等。数据库安全组非常重要，因为我们希望使用在第 3 步中创建的安全组。输入详细信息后点击下一步。请看以下截图：
接下来，在管理选项页面，你可以指定数据库实例的备份和维护选项，如以下截图所示：
最后，你可以在审核页面查看你的数据库实例的详细信息。
新 MySQL 数据库实例的创建和配置大约需要一分钟左右，完成后，它将出现在数据库实例列表中，正如以下截图所示：
在你能够连接到 Amazon RDS MySQL 数据库实例之前，你需要了解新创建实例的详细信息。可以通过点击数据库实例列表中的详细信息图标来查看 MySQL 数据库实例的详细信息，正如以下截图所示：
点击详细信息页面图标后，你可以查看到可以连接的 MySQL 主机名。主机信息位于Endpoint旁边，且它将是*.rds.amazonaws.com的子域名，如以下截图所示：
若要连接到 MySQL 数据库实例，你需要在 Gear 上安装 MySQL 命令行客户端。每个 OpenShift 应用 Gear 已经预装了mysql命令行代理，所以你无需做任何额外操作。只需使用rhc ssh命令 SSH 连接到应用 Gear，然后运行以下命令：

提示

用户名和密码对应你在第 10 步中创建的内容。
```
$ mysql --host <host_endpoint>.rds.amazonaws.com --port 3306 -u <username> -p<password> <database_name>
```

一旦连接成功，你可以执行任何 SQL 命令。要检查 MySQL 数据库的运行时，你可以运行以下命令：

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 12
Server version: 5.5.33-log Source distribution

Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> SHOW STATUS like 'Uptime';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| Uptime        | 2227  |
+---------------+-------+
1 row in set (0.33 sec)

mysql>

它是如何工作的…

每个 Amazon RDS 实例都有一个防火墙，防止任何外部访问。因此，在你创建 Amazon RDS 实例之前，你应该创建一个新的数据库安全组，允许某个 IP 范围的访问。从第 1 步到第 6 步，你已经创建了一个新的安全组，允许所有 IP 地址连接到你的 Amazon MySQL 数据库实例。0.0.0.0/0值允许所有 IP 访问数据库实例。这在如 OpenShift 等不提供静态 IP 的环境中尤为重要。

第 7 步到第 14 步帮助你创建了一个新的 Amazon RDS MySQL 数据库实例。你需要提供与数据库实例相关的详细信息，Amazon RDS 会根据你输入的详细信息来配置数据库实例。在第 14 步时，你已经有了一个可以从外部世界连接的 MySQL 数据库实例。你可以从本地机器或者 OpenShift 应用 Gear 连接到它。

步骤 15 和步骤 16 帮助你查看了 MySQL 数据库实例的详细信息。最重要的细节是 MySQL 数据库实例所托管的主机名。在步骤 17 中，你使用这些详细信息通过 mysql 命令行客户端连接到 Amazon RDS MySQL 数据库实例。在步骤 18 中，你运行了一个简单的 SQL 查询以检查数据库的运行时间。

还有更多…

你可以通过配置 RDS 实例只接受来自授权用户的 SSL 加密连接来使 MySQL 数据库连接更加安全。要配置 SSL，请执行以下 SQL 命令。请将用户名替换为你的 MySQL 数据库实例的用户名：

mysql> GRANT USAGE ON *.* TO 'username'@'%' REQUIRE SSL;

现在，如果你退出连接并尝试使用步骤 5 中提到的 mysql 命令重新登录，你将会遇到访问被拒绝的错误：

[myapp-osbook.rhcloud.com 530f227e50044604f9000060]\> mysql --host <host_endpoint>.rds.amazonaws.com --port 3306 -u <username> -p<password> <db_name>
ERROR 1045 (28000): Access denied for user 'username'@'ip-10-181-217-44.ec2.internal' (using password: YES)

要连接到 MySQL 数据库实例，首先需要下载 Amazon RDS CA 证书。请前往 $OPENSHIFT_DATA_DIR，然后运行以下 wget 命令：

[myapp-osbook.rhcloud.com]\> cd $OPENSHIFT_DATA_DIR
[myapp-osbook.rhcloud.com data]\> wget https://s3.amazonaws.com/rds-downloads/mysql-ssl-ca-cert.pem
Next, connect to RDS instance using mysql command-line as shown below. Please note the use of ssl_ca parameter to reference the public key.
 [myapp-osbook.rhcloud.com data]\> mysql --host <host_endpoint>.rds.amazonaws.com --port 3306 -u <username> -p<password> <db_name> --ssl_ca=mysql-ssl-ca-cert.pem 
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 20
Server version: 5.5.33-log Source distribution
mysql>

参见

将 MySQL 扩展包添加到应用程序 配方

第五章：使用 PostgreSQL 与 OpenShift 应用程序

本章介绍了一些教程，展示了如何开始使用 OpenShift PostgreSQL 数据库扩展模块。您将学习如何添加和管理 PostgreSQL 扩展模块，如何备份 PostgreSQL 数据库，如何列出并安装 PostgreSQL 扩展，如何与 OpenShift 应用程序一起使用 EnterpriseDB PostgreSQL Cloud Database 服务。本章中的具体教程包括：

将 PostgreSQL 扩展模块添加到您的应用程序
从本地计算机访问 PostgreSQL 扩展模块
从本地计算机使用 pgAdmin 连接 PostgreSQL 扩展模块
更新 PostgreSQL 的 max_connections 设置
使用 .psqlrc 配置文件来配置 OpenShift 应用程序的 psql shell
执行定期的 PostgreSQL 数据库备份
在 OpenShift 中使用 EnterpriseDB PostgreSQL Cloud Database
安装 PostgreSQL 扩展

介绍

PostgreSQL 是一个流行的开源关系型数据库，全球许多 Web 应用程序都在使用它。OpenShift 支持一个标准化的、经过安全强化的 PostgreSQL 数据库版本。由于您使用的是标准版本的数据库，因此不会被限制在 OpenShift 内，并且在需要时可以轻松地迁移您的数据。

本章将使用我们在第三章中创建的 PHP 5.4 应用程序，创建与管理应用程序。如果您没有运行任何 OpenShift 应用程序，可以通过运行以下命令来创建一个新的 OpenShift 应用程序：

$ rhc create-app myapp php-5.4

如果在 OpenShift 中运行数据库不可行，或者您已经投资于第三方服务，您还可以使用第三方数据库服务，如 EnterpriseDB Cloud Database。另一个您可能想使用第三方数据库服务的原因是，OpenShift PostgreSQL 扩展模块不具备可扩展性。因此，对于需要水平可扩展且高度可用的 PostgreSQL 服务的应用程序，您可以使用第三方提供商（如 EnterpriseDB）与您的应用程序一起使用。

将 PostgreSQL 扩展模块添加到您的应用程序

在撰写本书时，OpenShift 支持两种版本的 PostgreSQL 数据库。您可以通过运行以下命令查看所有支持的 PostgreSQL 版本：

$ rhc cartridges|grep postgresql
postgresql-8.4      PostgreSQL 8.4                          addon
postgresql-9.2      PostgreSQL 9.2                          addon

在本教程中，您将学习如何将 PostgreSQL 9.2 扩展模块添加到您的 OpenShift 应用程序中。

准备工作

要完成此步骤，您需要在机器上安装 rhc 命令行客户端。有关详细信息，请参阅第一章，开始使用 OpenShift中关于安装 OpenShift rhc 命令行客户端的配方。另外，我们将使用在第三章，创建和管理应用程序中，使用 rhc 命令行客户端创建 OpenShift 应用程序配方中创建的应用程序。

如何操作……

要将 PostgreSQL 9.2 载荷安装到myapp应用程序中，请打开一个新的命令行终端，切换到myapp目录位置，然后执行以下命令：

$ rhc add-cartridge --app myapp -c postgresql-9.2

这将会在您的应用程序服务器上安装一个新的 PostgreSQL 服务器实例。-c选项用于指定载荷名称，--app选项用于指定应用程序名称。如果您在应用程序目录内运行命令，--app选项不是必需的。-c选项是必需的，但您可以省略-c，因为 rhc 命令行客户端足够智能，能够推断出 PostgreSQL 9.2 是载荷名称。命令可以简化为如下：

$ rhc cartridge-add postgresql-9

您可以使用rhc show-cartridge命令如下查看载荷详细信息：

$ rhc cartridge-show postgresql
Using postgresql-9.2 (PostgreSQL 9.2) for 'postgresql'
postgresql-9.2 (PostgreSQL 9.2)
-------------------------------
 Gears:          Located with php-5.4
 Connection URL: postgresql://$OPENSHIFT_POSTGRESQL_DB_HOST:$OPENSHIFT_POSTGRESQL_DB_PORT
 Database Name:  myapp
 Password:       dPLehGi-UGQi
 Username:       admin8awrwrc

您可以使用stop命令如下停止 PostgreSQL 服务器：

$ rhc cartridge-stop postgresql

您可以使用restart命令如下重启 PostgreSQL 服务器：

$ rhc cartridge-restart postgresql

如果您想从应用程序中移除 PostgreSQL 服务器，可以使用remove命令如下：

$ rhc cartridge-remove postgresql –-confirm

如何工作……

当您运行rhc cartridge-add命令时，rhc 将向 OpenShift 服务器发出一个 HTTP POST 请求。OpenShift 服务器将接收请求并在您的应用程序服务器上安装一个新的 PostgreSQL 数据库实例。在 Provision PostgreSQL 服务器之后，rhc 客户端将在命令行终端显示数据库详细信息，如下所示：

Adding postgresql-9.2 to application 'myapp' ... done

postgresql-9.2 (PostgreSQL 9.2)
-------------------------------
 Gears:          Located with php-5.4
 Connection URL: postgresql://$OPENSHIFT_POSTGRESQL_DB_HOST:$OPENSHIFT_POSTGRESQL_DB_PORT
 Database Name:  myapp
 Password:       dPLehGi-UGQi
 Username:       admin8awrwrc

PostgreSQL 9.2 database added.  Please make note of these credentials:

 Root User: admin8awrwrc
 Root Password: dPLehGi-UGQi
 Database Name: myapp

Connection URL: postgresql://$OPENSHIFT_POSTGRESQL_DB_HOST:$OPENSHIFT_POSTGRESQL_DB_PORT

您可以通过 SSH 连接到应用程序服务器，查看 PostgreSQL 安装情况：

$ rhc ssh --app myapp

然后，运行ls命令查看服务器目录结构，您将看到postgresql目录：

[myapp-osbook.rhcloud.com 531069cd5973cad58c0000b6]\> ls -p
app-deployments/  app-root/  git/  php/  postgresql/

postgresql目录是您 PostgreSQL 安装的位置，且不会与任何其他 OpenShift 应用程序或用户共享。它仅供您的应用程序使用，只有您的应用程序可以访问它。

您还可以使用psql命令行客户端连接到您的 PostgreSQL 服务器：

[myapp-osbook.rhcloud.com 531069cd5973cad58c0000b6]\> psql
psql (9.2.4)
Type "help" for help.

myapp=#

现在，您可以对 PostgreSQL 服务器运行 SQL 命令。要查看所有数据库，请运行以下命令：

myapp=# \list
 List of databases
 Name    |    Owner     | Encoding |   Collate   |    Ctype    |   Access privileges 
-----------+--------------+----------+-------------+-------------+-----------------------
 myapp     | admin8awrwrc | UTF8     | en_US.UTF-8 | en_US.UTF-8 | 
 postgres  | postgres     | UTF8     | en_US.UTF-8 | en_US.UTF-8 | 
 template0 | postgres     | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
 |              |          |             |             | postgres=CTc/postgres
 template1 | postgres     | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
 |              |          |             |             | postgres=CTc/postgres
(4 rows)

myapp=#

myapp数据库对应您的应用程序数据库。您可以使用此数据库来支持您的应用程序，或者使用CREATE DATABASE命令创建一个新数据库。要查看 PostgreSQL 服务器的运行时间，请运行以下命令：

myapp=# select date_trunc('minute',current_timestamp - pg_postmaster_start_time()) as "postgresql_uptime";
 postgresql_uptime 
-------------------
 00:12:00
(1 row)

输出显示 PostgreSQL 服务器已运行了 12 分钟。

您可以查看所有可用的 PostgreSQL 命令行实用程序，通过输入 pg_ 然后按 Tab 键。 Tab 键启用命令行自动完成功能，允许命令行程序自动填写命令的剩余部分：

[myapp-osbook.rhcloud.com 531069cd5973cad58c0000b6]\> pg_
pg_archivecleanup  pg_controldata     pg_dumpall         pg_resetxlog       pg_test_fsync 
pg_basebackup      pg_ctl             pg_filedump        pg_restore         pg_test_timing 
pg_config          pg_dump            pg_receivexlog     pg_standby

还有更多内容…

您也可以从 OpenShift Web 控制台添加 PostgreSQL 数据库。转到 openshift.redhat.com/app/console/applications，并点击 myapp 应用程序查看详细信息。在 myapp 应用程序详细信息页面上，您将看到添加 PostgreSQL 数据库的选项，如下截图所示。点击 Add PostgreSQL 9.2 添加 PostgreSQL 9.2 配置。

接下来，您将被引导到页面以添加 PostgreSQL 配置。点击 Add Cartridge 添加 PostgreSQL 数据库到您的应用程序。查看以下截图：

安装 PostgreSQL 配置后，将显示 PostgreSQL 数据库详细信息，如下：

另请参阅

使用本地机器访问 PostgreSQL 配置的方法

使用本地机器访问 PostgreSQL 配置

在 将 PostgreSQL 配置添加到您的应用程序 配方中，您学习了如何通过执行 SSH 到应用程序配置获取 PostgreSQL 数据库。在本配方中，您将学习如何从本地机器连接到 PostgreSQL 数据库。

准备工作

要完成此配方，您需要一个带有 PostgreSQL 配置的应用程序。请参考本章的 将 PostgreSQL 配置添加到您的应用程序 配方，了解如何安装 PostgreSQL 配置。此外，您还需要在您的机器上安装 psql 命令行客户端。您可以从官方网站 www.postgresql.org/download/ 下载 PostgreSQL 服务器。

如何实现…

执行以下步骤访问本地机器上的 PostgreSQL 配置：

打开命令行终端，并切换到 myapp 应用程序目录。执行以下命令将远程端口转发到本地机器：

$ rhc port-forward 
Checking available ports ... done
Forwarding ports ...
Address already in use - bind(2) while forwarding port 5432\. Trying local port 5433

To connect to a service running on OpenShift, use the Local address

Service    Local               OpenShift
---------- -------------- ---- -----------------
httpd      127.0.0.1:8080  =>  127.6.76.129:8080
postgresql 127.0.0.1:5433  =>  127.6.76.130:5432

使用 psql 命令行客户端从本地机器连接到 PostgreSQL 服务器，操作如下：
```
$ psql --host <host> --port <port> --username <username> myapp
```
请将 <username> 替换为您的 PostgreSQL 配置用户名和密码。主机和端口值可以在 rhc port-forward 命令的输出中找到。如步骤 1 所示，PostgreSQL 在 127.0.0.1 主机和端口 5433 上可用。您可以通过运行 rhc show-app 或 rhc cartridge-show postgresql 命令查看用户名和密码。

连接后，您可以运行任何有效的 SQL 命令。\list 命令显示可用数据库列表：

adminvtxt5s8@127.0.0.1:5433 myapp#\list
 List of databases
 Name    |    Owner     | Encoding |   Collate   |    Ctype    |   Access privileges 
-----------+--------------+----------+-------------+-------------+-------
----------------
 myapp     | adminvtxt5s8 | UTF8     | en_US.UTF-8 | en_US.UTF-8 | 
 postgres  | postgres     | UTF8     | en_US.UTF-8 | en_US.UTF-8 | 
 template0 | postgres     | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
 |              |          |             |             | postgres=CTc/postgres
 template1 | postgres     | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
 |              |          |             |             | postgres=CTc/postgres
(4 rows)

工作原理…

在第 1 步中，你使用了rhc port-forward命令将所有远程端口转发到本地机器。rhc port-forward命令是 SSH 端口转发的一个封装，使远程机器上的端口可以在本地机器上使用。一个本来对你不可用的远程机器端口，可以像本地端口一样使用。该命令返回你可以从本地机器连接的端口列表。

如第 1 步所示，postgresql进程在127.0.0.1主机的 5433 端口上可用。

在第 2 步中，你从本地机器连接到 PostgreSQL，传递了数据库的用户名、密码、主机和端口。成功连接后，你在第 3 步运行了 SQL 命令。

要终止端口转发，只需在运行rhc port-forward命令的命令行终端上按Ctrl + C。

另见

将 PostgreSQL 卡片添加到应用程序的食谱
从本地机器通过 pgAdmin 连接到 PostgreSQL 卡片的食谱

从本地机器通过 pgAdmin 连接到 PostgreSQL 卡片

在从本地机器访问 PostgreSQL 卡片的食谱中，你学会了如何使用端口转发从本地机器的psql命令行客户端连接到 PostgreSQL 卡片。在本食谱中，你将学习如何使用 pgAdmin 从本地机器连接到 PostgreSQL 卡片。pgAdmin 是一个综合性的 PostgreSQL 数据库设计与管理系统，适用于 Unix 和 Windows 系统。

准备工作

要完成本食谱，你需要一个包含 PostgreSQL 卡片的应用程序。请参考本章中的将 PostgreSQL 卡片添加到应用程序食谱，了解如何将 PostgreSQL 卡片添加到应用程序中。此外，你还需要在本地机器上安装 pgAdmin。你可以从官方网站下载 pgAdmin，www.pgadmin.org/download/。

操作方法…

执行以下步骤，通过 pgAdmin 客户端连接 PostgreSQL 卡片：

打开命令行终端，并将目录更改为myapp应用程序目录。执行以下命令，将远程端口转发到本地机器：
```
$ rhc port-forward --app myapp
```
启动 pgAdmin 应用程序，然后点击套接字图标以创建新的连接。
通过输入 PostgreSQL 数据库的详细信息来设置新连接。你可以使用rhc show-app或rhc cartridge-show mysql命令获取 PostgreSQL 卡片的用户名和密码。请查看以下截图：
通过点击确定按钮连接到 PostgreSQL 卡片。
你会在左侧导航窗格中看到一个连接，如下图所示：
接下来，首先点击myapp数据库，然后点击 SQL 图标以打开 SQL 编辑器。请看以下截图：

在 SQL 编辑器中运行以下 SQL 查询以检查数据库的运行时间：

select date_trunc('minute',current_timestamp – pg_postmaster_start_time()) as "postgresql_uptime";

它是如何工作的…

在步骤 1 中，您使用了rhc port-forward命令将所有远程端口转发到本地机器。这使得可以连接到运行在应用程序服务器中的 PostgreSQL 数据库。步骤 2 到步骤 6 中，您创建了一个新的 PostgreSQL 连接，并通过 pgAdmin 连接到 PostgreSQL 卡片。在步骤 7 中，您使用 SQL 编辑器执行 SQL 查询，以验证连接是否正在从您在myapp应用程序中安装的 PostgreSQL 卡片获取数据。

另请参阅

将 PostgreSQL 卡片添加到应用程序配方
从本地机器访问 PostgreSQL 卡片配方

更新 PostgreSQL `max_connections` 设置

OpenShift PostgreSQL 卡片配置为最多允许 100 个客户端连接。如果连接到 PostgreSQL 服务器的客户端数量超过此阈值，PostgreSQL 将开始给出FATAL too many connections错误。在此配方中，你将学习如何更新 PostgreSQL 卡片的max_connections设置。

最大连接数由postgresql.conf配置文件中的max_connections设置决定。OpenShift 不允许用户修改postgresql.conf配置文件。更改max_connections设置的推荐方法是通过设置环境变量。

准备工作

要完成此配方，您需要一个安装了 PostgreSQL 卡片的应用程序。请参阅本章中的将 PostgreSQL 卡片添加到应用程序配方，了解如何安装 PostgreSQL 卡片。

如何操作…

执行以下步骤来更新 PostgreSQL max_connections 设置：

要将最大连接数设置为200，请打开命令行终端并运行以下命令：
```
$ rhc env-set OPENSHIFT_POSTGRESQL_MAX_CONNECTIONS=200 --app myapp
```
设置环境变量后，必须重启 PostgreSQL 卡片才能使更改生效，步骤如下：
```
$ rhc cartridge-restart postgresql --app myapp
```

它是如何工作的…

PostgreSQL 数据库将其配置保存在安装目录conf中的postgresql.conf文件中。max_connections配置设置控制了 PostgreSQL 服务器允许的最大客户端连接数。你可以通过对 PostgreSQL 数据库运行查询来查看max_connections设置。要查看 OpenShift PostgreSQL 卡片的max_connections，请通过 SSH 连接到应用程序服务器，并运行以下命令：

myapp=# show max_connections;
 max_connections 
-----------------
 100
(1 row)

OpenShift 出于安全原因不允许用户修改 postgresql.conf 文件。为了允许用户修改 max_connections 设置，OpenShift 提供了一个名为 OPENSHIFT_POSTGRESQL_MAX_CONNECTIONS 的环境变量，可以用来设置 max_connections 系统变量。在第 1 步中，你将 OPENSHIFT_POSTGRESQL_MAX_CONNECTIONS 环境变量设置为 200。除非你重新启动数据库，否则 PostgreSQL 服务器不会读取新值。因此，在第 2 步中，你使用 rhc cartridge-restart 命令重新启动了数据库。为了验证 max_connections 值是否更新，你可以按照如下方式再次运行 SQL 命令：

myapp=# show max_connections;
 max_connections 
-----------------
 200
(1 row)

还有更多内容…

OPENSHIFT_POSTGRESQL_MAX_CONNECTIONS 变量并不是 PostgreSQL 插件支持的唯一配置属性。你可以使用环境变量设置以下属性。要了解这些设置，请参考以下文档：wiki.postgresql.org/wiki/Tuning_Your_PostgreSQL_Server。

属性	环境变量
`shared_buffers`	`OPENSHIFT_POSTGRESQL_SHARED_BUFFERS`
`datestyle`	`OPENSHIFT_POSTGRESQL_DATESTYLE`
`ssl`	`OPENSHIFT_POSTGRESQL_SSL_ENABLED`
`lc_messages`	`OPENSHIFT_POSTGRESQL_LOCALE`
`lc_monetary`	`OPENSHIFT_POSTGRESQL_LOCALE`
`lc_numeric`	`OPENSHIFT_POSTGRESQL_LOCALE`
`lc_time`	`OPENSHIFT_POSTGRESQL_LOCALE`

另见

使用 .psqlrc 配置文件配置 OpenShift 应用程序的 psql shell 配方
从本地机器访问 PostgreSQL 插件 配方

使用 .psqlrc 配置文件配置 OpenShift 应用程序的 psql shell

PostgreSQL 提供了一个名为 .psqrc 的启动文件，它决定了 psql 交互式命令行客户端的行为。就像 bashrc 一样，psql 客户端实用程序会在启动时尝试读取并执行系统范围的 psqlrc 文件和用户的 ~/.psqlrc 文件中的命令。在这个配方中，你将学习如何使用自己的 .psqlrc 配置文件来配置你的 OpenShift 应用程序 psql shell。

准备工作

要完成这个配方，你需要一个包含 PostgreSQL 插件的应用程序。请参考本章中的 将 PostgreSQL 插件添加到你的应用程序 配方，了解如何安装 PostgreSQL 插件。

如何操作…

执行以下步骤配置 psql shell：

更改目录到 myapp，然后通过 SSH 进入应用程序的 gear：
```
$ rhc ssh --app myapp
```

在 $OPENSHIFT_DATA_DIR 中创建一个名为 .psqlrc 的新文件：

[myapp-osbook.rhcloud.com 531069cd5973cad58c0000b6]\> touch $OPENSHIFT_DATA_DIR/.psqlrc

现在，让我们配置 psql shell，以便存储你输入过的命令的历史记录，这样你就可以再次运行它们。这是通过设置 HISTFILE 位置来实现的，如以下命令所示。:DBNAME 变量允许 psql 为每个数据库存储不同的历史记录。我们还将启用 psql 打印每个命令的执行时间。通过使用 \timing 选项来完成。要自定义 psql shell，请将以下内容添加到 .psqrc 文件中：
```
\set HISTFILE ~/app-root/data/.psql_history- :DBNAME
\timing on
```
注销 SSH 会话，并创建一个新的环境变量 PSQLRC，指向新的 .psqlrc 文件位置：
```
$ rhc env-set PSQLRC<OPENSHIFT_DATA_DIR>data/.psqlrc
```
请将 OPENSHIFT_DATA_DIR 替换为你的 OPENSHIFT_DATA_DIR 位置。你可以通过运行以下命令来获取该位置：
```
$ rhc ssh --app myapp --command 'cd $OPENSHIFT_DATA_DIR && pwd'
```

再次使用 rhc ssh 命令 SSH 登录到应用程序服务器，然后运行 psql 命令。执行查询后，你将看到查询的执行时间：

adminvtxt5s8:myapp#SELECT pid, usename from pg_stat_activity;
 pid   |   usename 
--------+--------------
 354468 | adminvtx
t5s8
(1 row)

Time: 85.372 ms

工作原理...

当 psql 启动时，它会查找一个名为 psqlrc 的文件，并运行文件中的任何命令以初始化环境。在 *nix 系统上，这个文件被称为 .psqlrc，通常位于用户的主目录下。从第 1 步到第 3 步，你在 $OPENSHIFT_DATA_DIR 下创建了一个新的 .psqlrc 文件。我们在 .psqlrc 文件中添加了一些配置。第一个配置确保 SQL 命令历史记录被保存在名为 .psql_history 的文件中，该文件位于 $OPENSHIFT_DATA_DIR 下。第二个配置指示 psql 为每个查询输出查询执行时间。

在第 4 步中，你创建了一个名为 PSQLRC 的新环境变量，该变量指向 .psqlrc 文件的位置。最后，在第 5 步中，你登录到 psql 客户端并运行了一个查询。查询执行后，psql 客户端还显示了执行查询所花费的时间。如上所示的命令行输出所示，查询大约花费了 86 毫秒。

另见

将 PostgreSQL 插件添加到你的应用程序 配方
从本地机器访问 PostgreSQL 插件 配方

执行定期的 PostgreSQL 数据库备份

在本配方中，你将学习如何执行 PostgreSQL 数据库的定期备份并将其上传到 Amazon S3。

准备工作

要完成本配方，你需要一个带有 PostgreSQL 插件的应用程序。请参阅本章中的 将 PostgreSQL 插件添加到你的应用程序 配方，了解如何添加 PostgreSQL 插件。同时，你需要拥有一个 Amazon AWS 账户。如果你还没有账户，请访问 aws.amazon.com/ 并注册一个新账户。

如何操作...

以下是执行每日定期备份 PostgreSQL 数据库的步骤：

访问 console.aws.amazon.com/s3/home，并创建一个新桶以存储你的数据库备份。
通过运行以下命令，将 cron 插件添加到你的应用程序：
```
$ rhc add-cartridge cron --app myapp
```

使用 SSH 进入应用程序 gear，并将 s3-bash 工具下载到 $OPENSHIFT_DATA_DIR。解压缩它到 s3-bash 目录中。请查看以下命令：

$ rhc ssh --app myapp
$ cd $OPENSHIFT_DATA_DIR
$ wget http://s3-bash.googlecode.com/files/s3-bash.0.02.tar.gz
$ mkdir s3-bash
$ tar -xf s3-bash.0.02.tar.gz -C s3-bash

在 $OPENSHIFT_DATA_DIR/s3-bash 目录下创建一个名为 AWSSecretAccessKeyIdFile 的新文件，并将你的 Amazon 密钥访问秘钥存储在其中。s3-bash 与 Amazon S3 通信时需要这个文件。

在本地机器上，在 .openshift/cron/minutely 目录下创建一个名为 database_backup.sh 的脚本，并添加以下内容：

#!/bin/bash
if [ `date +%H:%M` == "23:50" ]
then
    FILE_NAME=$(date +"%Y%m%d%H%M")
    pg_dump --username=$OPENSHIFT_POSTGRESQL_DB_USERNAME --no-password --host=$OPENSHIFT_POSTGRESQL_DB_HOST $BACKUP_DATABASE_NAME > $OPENSHIFT_DATA_DIR/$FILE_NAME.sql
    echo "Took PostgreSQL Dump" >> $OPENSHIFT_CRON_DIR/log/backup.log
    $OPENSHIFT_DATA_DIR/s3-bash/s3-put -k $AWS_ACCESS_KEY_ID -s $OPENSHIFT_DATA_DIR/s3-bash/AWSSecretAccessKeyIdFile -T $OPENSHIFT_DATA_DIR/$FILE_NAME.sql /$AWS_S3_BUCKET/$FILE_NAME.sql
    echo "Uploaded dump to Amazon S3" >> $OPENSHIFT_CRON_DIR/log/backup.log
    rm -f $OPENSHIFT_DATA_DIR/$FILE_NAME.sql
fi

上述脚本将在每天的 23:50 执行，并运行 pg_dump 命令生成数据转储文件。然后，使用 s3-bash API 将文件传输到 Amazon S3。最后，上传文件后，它会从应用程序 gear 中删除 SQL 转储文件。

现在，我们需要设置环境变量，以便脚本能够与 Amazon S3 通信，具体操作如下所示。如果你不确定如何访问你的安全凭证，请参考文档 docs.aws.amazon.com/general/latest/gr/getting-aws-sec-creds.html。请查看以下命令：
```
$ rhc env-set AWS_ACCESS_KEY_ID=< Your Amazon ACCESS_KEY_ID>
$ rhc env-set BACKUP_DATABASE_NAME=<Database you want to take backup off>
$ rhc env-set AWS_S3_BUCKET=<Amazon S3 bucket name >
```
提交代码并将代码推送到 OpenShift gear。每晚 23:50，数据库备份将会执行，备份文件将上传到 Amazon S3：
```
$ git commit –am "database backup script added"
$ git push
```

它是如何工作的…

在前面的步骤中，你启用了 PostgreSQL 数据库 cartridge 的每日备份。该配方使用 cron cartridge 将数据库转储上传到 Amazon S3。

在第 1 步中，你创建了一个新的 Amazon S3 桶来存储 PostgreSQL 数据库备份。Amazon S3 被广泛用于存储静态文件，是此任务的理想选择。接下来，你将 cron cartridge 添加到应用程序中。cron cartridge 将用于在特定时间执行每日备份。

Amazon S3 提供了一个 REST 服务，用户可以用它对 S3 桶进行操作。亚马逊为多种编程语言提供了其 REST API 的封装，方便开发者将其集成到应用中。为了保持此配方与语言无关，我们使用了 Amazon S3 的 bash 封装器。虽然 Amazon 官方并不支持这个封装器，但它运行得非常好。在第 3 步中，你通过 wget 下载了 s3-bash。tar.gz 文件被存储在 $OPENSHIFT_DATA_DIR 中。接着，你将 tar.gz 解压到 s3-bash 目录中。

接下来，在第 4 步中，你创建了一个名为 AWSSecretAccessKeyIdFile 的文件，用于存储 Amazon 访问密钥秘钥。s3-bash 封装器使用该文件存储 AWS Secret Access Key ID，以避免其出现在正在运行的进程列表中（通过 ps 命令查看）。

在第 5 步中，你创建了一个将在每晚 23:50 执行的 bash 脚本。该脚本首先使用 pg_dump 命令备份数据库，然后将文件上传到 Amazon S3。文件名使用当前时间戳。最后，在将备份上传到 S3 后，脚本会删除备份文件以节省磁盘空间。

在第 6 步中，你创建了备份脚本所需的三个环境变量。最后，在第 7 步中，你提交了更改并将它们推送到 OpenShift 应用程序。

另见

将 PostgreSQL 卡片添加到你的应用程序配方

使用 EnterpriseDB PostgreSQL Cloud Database 与 OpenShift

在这个配方中，你将学习如何将 EnterpriseDB PostgreSQL Cloud Database 与 OpenShift 应用程序集成。你还可以像我们使用 Amazon RDS MySQL 数据库实例一样，使用 Amazon RDS PostgreSQL 数据库实例。EnterpriseDB Cloud Database 允许你在 Amazon EC2 或 HP Cloud 服务上设置一个复制、分片且高度可用的 PostgreSQL 集群。你可以定期备份数据，并在不需要任何管理技能的情况下水平扩展。

准备工作

要完成这个配方，你需要一个 OpenShift 应用程序。有关更多信息，请参考第三章，创建和管理应用程序章节中的使用 rhc 命令行客户端创建 OpenShift 应用程序配方。

如何操作…

执行以下步骤，学习如何将 OpenShift 应用程序连接到 EnterpriseDB PostgreSQL 数据库：

访问www.enterprisedb.com/cloud-database/amazon，并点击免费试用部分的立即开始按钮。
接下来，你将被引导到注册页面。输入有效信息后，点击提交按钮。
注册成功后，你将被重定向到仪表板控制台，如下图所示。在这里，你可以启动一个数据库集群，查看你正在使用的资源，或者查看服务的状态更新。在仪表板底部，有关于 PostgreSQL CloudDB 的教程和文档链接。
现在，我们将通过点击启动数据库集群来创建第一个 EnterpriseDB Cloud 数据库集群。这将弹出一个窗口，在其中你需要提供集群的详细信息，如下图所示。详细信息包括集群名称、PostgreSQL 版本、Amazon 实例大小、节点数量以及主用户名和密码。如何操作…
输入集群详情后，你可以选择保留多少个备份，并决定何时进行备份。使用默认选项即可。
最后，点击启动按钮。这将启动创建复制数据库集群的过程，如下图所示。启动集群需要几分钟时间，请耐心等待。在集群标签页中，你可以查看你拥有的数据库集群信息。在详情标签页中，你可以看到主节点和副本节点的地址。如何操作…

创建一个复制的数据库集群
要连接到 EnterpriseDB PostgreSQL Cloud DB，请通过 SSH 登录到应用程序设备，并使用psql命令连接到 Cloud DB。每个应用程序设备上都安装了 psql。主机地址是你可以从第 6 步获得的主机地址。
```
$ psql -h host_address.compute-1.amazonaws.com -p 9999 -U postgres -W postgres
```

它是如何工作的……

第 1 步到第 6 步帮助你创建了一个新的 EnterpriseDB PostgreSQL Cloud DB 实例。你需要提供与数据库实例相关的详细信息，EnterpriseDB 将根据你输入的详细信息配置一个 PostgreSQL 数据库实例。在第 6 步时，你已经拥有了一个可以从外部连接的运行中的 PostgreSQL 数据库实例。你可以从本地机器或 OpenShift 应用程序设备连接到它。

在第 7 步中，你使用数据库详细信息通过 psql 命令行客户端连接到 EnterpriseDB PostgreSQL 实例。

另见

将 PostgreSQL 组件添加到你的应用程序教程

安装 PostgreSQL 扩展

扩展是你可以安装到 PostgreSQL 数据库中的插件，用于扩展其基本功能。你可以在 PostgreSQL 扩展网络网站上找到可用的 PostgreSQL 扩展列表，www.pgxn.org/。OpenShift PostgreSQL 组件包中附带了一份扩展列表。这些扩展默认并未安装，但如果你需要，可以使用它们。在本教程中，你将学习如何在 OpenShift PostgreSQL 组件中安装扩展。

准备工作

要完成本教程，你需要一个带有 PostgreSQL 组件的应用程序。请参考本章中的将 PostgreSQL 组件添加到你的应用程序教程，学习如何将 PostgreSQL 组件添加到应用程序中。

如何操作……

执行以下步骤以安装扩展：

打开一个新的命令行终端，并使用rhc ssh命令 SSH 登录到应用程序设备。登录后，运行 psql 命令行工具连接到 PostgreSQL 组件。
在 psql shell 中，运行以下命令以查看所有可用的扩展：
```
# select * from pg_available_extensions;
```
接下来，执行以下 SQL 命令来安装fuzzystrmatch扩展：
```
# create extension fuzzystrmatch;
```

你可以通过运行\dx命令查看所有已安装的扩展：

#\dx 
 List of installed extensions
 Name      | Version |   Schema   |                     Description 
---------------+---------+------------+-----------------------------------------------------
 fuzzystrmatch | 1.0     | public     | determine similarities and distance between strings
 plpgsql       | 1.0     | pg_catalog | PL/pgSQL procedural language
(2 rows)

你可以通过运行以下 SQL 命令从 psql 组件中删除扩展：
```
# drop extension fuzzystrmatch;
```

它是如何工作的……

每个 OpenShift PostgreSQL 组件都可以访问扩展列表。这些扩展默认不会安装，因为并非所有应用程序都需要这些扩展。要查看所有可用的扩展，你可以使用第 2 步中所示的select * from pg_available_extensions SQL 命令。在撰写本书时，PostgreSQL 组件预先打包了 51 个扩展。这些扩展可以通过运行CREATE EXTENSION SQL命令来安装，如第 2 步所示。CREATE EXTENSION命令会编译并安装扩展。在第 3 步中，你安装了fuzzystrmatch扩展。

fuzzystrmatch 扩展提供了多个函数，用于确定字符串之间的相似性和差异性。要查看 fuzzystrmatch 扩展的详细信息，你可以运行以下命令：

\dx+ fuzzystrmatch
 Objects in extension "fuzzystrmatch"
 Object Description 
----------------------------------------------------------------------------
 function difference(text,text)
 function dmetaphone_alt(text)
 function dmetaphone(text)
 function levenshtein_less_equal(text,text,integer)
 function levenshtein_less_equal(text,text,integer,integer,integer,integer)
 function levenshtein(text,text)
 function levenshtein(text,text,integer,integer,integer)
 function metaphone(text,integer)
 function soundex(text)
 function text_soundex(text)
(10 rows)
To find the levenshtein distance between Hello and Hallo, you can run command shown below.
select levenshtein('Hello','Hallo');
 levenshtein 
-------------
 1
(1 row)

你可以使用 DROP EXTENSION 命令删除一个扩展。

另请参见

将 PostgreSQL 插件添加到你的应用程序 配方

第六章. 使用 MongoDB 和第三方数据库扩展包与 OpenShift 应用程序一起使用

本章节提供了多个教程，向您展示如何开始使用 OpenShift MongoDB 扩展包。我们还将介绍如何使用可下载的 MariaDB 和 远程字典服务器（Redis）扩展包。本章节中的具体教程包括：

将 MongoDB 扩展包添加到您的应用程序
将 RockMongo 扩展包添加到您的应用程序
从本地机器访问 MongoDB 扩展包
使用 Robomongo 从本地机器连接到 MongoDB 扩展包
启用 MongoDB 扩展包的 REST 接口
执行定期的 MongoDB 数据库备份
使用 MongoLab MongoDB-as-a-Service 与 OpenShift 配合使用
将 MariaDB 扩展包添加到您的应用程序
将 Redis 扩展包添加到您的应用程序

介绍

MongoDB 是一个流行的开源面向文档的 NoSQL 数据存储。它设计用于可扩展性，并将复杂的对象图存储在单个文档中。它支持动态查询、二级索引、快速的原子更新、聚合以及内建的复制和分片支持。

本章节将使用我们在第三章，创建和管理应用程序中创建的 PHP 5.4 应用程序。如果您没有正在运行的 OpenShift 应用程序，则可以通过运行以下命令创建一个新的 OpenShift 应用程序：

$ rhc create-app myapp php-5.4

将 MongoDB 扩展包添加到您的应用程序

在本教程中，您将学习如何将 MongoDB 扩展包添加到您的 OpenShift 应用程序。MongoDB 是一个面向文档的、水平可扩展的 NoSQL 数据存储。

准备工作

为了执行这个教程，您需要在机器上安装 rhc 命令行客户端。有关详细信息，请参考第一章，OpenShift 入门中的 安装 OpenShift rhc 命令行客户端 章节。另外，我们将使用在第三章，创建和管理应用程序中创建的应用程序。

如何操作…

要将 MongoDB 扩展包安装到 myapp 应用程序中，请按照以下步骤操作：

打开一个新的命令行终端，切换到 myapp 目录位置并执行以下命令：
```
$ rhc cartridge-add c mongodb-2.4 --app myapp
```
这将会在您的应用程序服务器上安装一个新的 MongoDB 实例。-c 选项用于指定扩展包名称，--app 选项用于指定应用程序名称。

您可以使用 rhc show-cartridge 命令查看扩展包的详细信息：

$ rhc show-cartridge mongodb --app myapp
Using mongodb-2.4 (MongoDB 2.4) for 'mongodb'
mongodb-2.4 (MongoDB 2.4)
-------------------------
 Gears:          Located with php-5.4
 Connection URL: mongodb://$OPENSHIFT_MONGODB_DB_HOST:$OPENSHIFT_MONGODB_DB_PORT/
 Database Name:  myapp
 Password:       DSdIxMVY8kd4
 Username:       admin

您还可以使用 stop 命令停止 MongoDB 服务器：
```
$ rhc stop-cartridge mongodb
```
您可以使用 restart 命令重启 MongoDB 服务器：
```
$ rhc cartridge-restart mongodb
```
如果您想从应用程序中移除 MongoDB 服务器，可以使用 remove 命令：
```
$ rhc cartridge-remove mongodb –-confirm
```

它是如何工作的…

当你运行rhc add-cartridge命令时，rhc会向 OpenShift 服务器发出一个 HTTP POST 请求。OpenShift 服务器将接收该请求，并为你的应用程序创建一个新的 MongoDB 数据库实例。在创建完 MongoDB 数据库后，rhc客户端将在命令行终端上显示数据库的详细信息。

你可以通过执行 SSH 连接到你的应用程序 gear 来查看 MongoDB 的安装情况：

$ rhc ssh --app myapp

然后，运行ls命令查看 gear 的目录结构，你将看到mongodb目录：

[myapp-osbook.rhcloud.com 52fb71aa5973caf609000026]\> ls -p
app-deployments/  app-root/  git/  mongodb/  php/

mongodb目录是你的mongodb安装，它不会与其他 OpenShift 应用程序或用户共享。它仅供你的应用程序使用，只有你的应用程序可以访问它。

你也可以使用mongo命令行客户端连接到 MongoDB 数据库，如下所示。从本地计算机访问 MongoDB 插件配方将讲解如何从本地计算机连接到 MongoDB：

[myapp-osbook.rhcloud.com 52fb71aa5973caf609000026]\> mongo
MongoDB shell version: 2.4.6
connecting to: 127.2.34.2:27017/admin
Welcome to the MongoDB shell.
For interactive help, type "help".
For more comprehensive documentation, see
 http://docs.mongodb.org/
Questions? Try the support group
 http://groups.google.com/group/mongodb-user
>

现在，你可以对 MongoDB 数据库运行命令。要查看所有数据库，请运行以下命令：

> show databases;
admin  0.03125GB
local  0.03125GB
myapp  0.03125GB

myapp数据库对应的是你的应用程序数据库。

你可以通过输入mongo并按Tab键两次来查看 gear 上所有可用的 MongoDB 命令行工具：

[myapp-osbook.rhcloud.com 52fb71aa5973caf609000026]\> mongo
mongo          mongod         mongoexport    mongoimport    mongoperf mongos         mongostat 
mongo_console  mongodump      mongofiles     mongooplog     mongorestore   mongosniff     mongotop

还有更多…

你也可以通过 OpenShift 网页控制台添加 MongoDB 数据库。访问openshift.redhat.com/app/console/applications，点击myapp应用程序查看详细信息。在myapp应用程序的详细网页上，你将看到一个添加 MongoDB 数据库的选项。点击Add MongoDB 2.4选项来添加 MongoDB 2.4 插件。

另见

将 RockMongo 插件添加到你的应用程序配方

将 RockMongo 插件添加到你的应用程序

RockMongo (rockmongo.com/)是一个免费的开源流行工具，使用 PHP 编程语言编写，通过网页浏览器管理 MongoDB 数据库。作为一个 Web 应用程序，RockMongo 使得无需在本地计算机上安装，即可轻松管理 MongoDB 服务器。在本配方中，你将学习如何在应用程序上安装 RockMongo 插件。

准备工作

要完成这个配方，你需要一个包含 MongoDB 插件的应用程序。参考将 MongoDB 插件添加到你的应用程序配方，了解如何安装 MongoDB 插件。

如何操作…

添加 RockMongo 插件的步骤如下：

要在myapp应用程序上安装 RockMongo 插件，请打开一个新的命令行终端，然后将目录切换到myapp所在的目录，并执行以下命令：
```
$ rhc add-cartridge rockmongo --app myapp
```
记下rhc cartridge-add命令返回的用户名和密码。你将需要这些凭据来登录 RockMongo。RockMongo 凭据与 MongoDB 数据库凭据相同，你可以随时通过执行rhc show-app或rhc cartridge-show mongodb-2.4命令查看它们。
使用第一步中的凭据登录到 RockMongo（https://myapp-{domain-name}.rhcloud.com/rockmongo/）。

工作原理……

当你运行rhc add-cartridge命令时，rhc客户端会向 OpenShift 服务器发送一个 HTTP POST 请求。OpenShift 服务器收到请求后，会在应用程序 Gear 上安装 RockMongo Cartridge。RockMongo Cartridge 支持所有受支持的应用程序类型（Java、Python、Node.js、Ruby、Perl 和 PHP）。你不需要创建 PHP 应用程序就能使用 RockMongo Cartridge。OpenShift 将启动一个 Apache 进程来运行 RockMongo 应用程序。

注意

只有在向应用程序添加了 MongoDB Cartridge 之后，你才能添加 RockMongo Cartridge。如果在添加 MongoDB Cartridge 之前尝试添加 RockMongo，系统会显示Cartridge 'rockmongo-1.1' can not be added without mongodb错误。

还有更多……

你还可以通过 OpenShift Web 控制台添加 RockMongo Cartridge。访问openshift.redhat.com/app/console/applications，然后点击myapp应用程序。要安装 RockMongo Cartridge，点击Add RockMongo 1.1网页链接。

另见

从本地机器访问 MongoDB Cartridge 这一篇
使用 Robomongo 从本地机器连接到 MongoDB Cartridge这一篇

从本地机器访问 MongoDB Cartridge

在将 MongoDB Cartridge 添加到你的应用程序这一篇中，你学习了如何通过 SSH 访问应用程序 Gear 中的 MongoDB 数据库。在本篇中，你将学习如何从本地机器连接到 MongoDB 数据库。

准备工作

要完成本教程，你需要一个带有 MongoDB Cartridge 的应用程序。请参考本章中的将 MongoDB Cartridge 添加到你的应用程序一节，了解如何添加 MongoDB Cartridge。此外，你的机器上还需要安装mongo命令行客户端。你可以从官方网站下载 MongoDB 数据库：www.mongodb.org/downloads/。

如何操作……

执行以下步骤，从本地机器连接到 MongoDB Cartridge：

打开命令行终端，并将目录切换到myapp应用程序目录。执行以下命令将远程端口转发到本地机器：

$ rhc port-forward --app myapp
Checking available ports ... done
Forwarding ports ...
Address already in use - bind(2) while forwarding port 8080\. Trying local port 8081

To connect to a service running on OpenShift, use the Local address

Service Local                OpenShift
------- --------------- ---- ----------------
httpd   127.0.0.1:8080   =>  127.2.34.1:8080
httpd   127.0.0.1:8081   =>  127.2.34.3:8080
mongodb 127.0.0.1:27017  =>  127.2.34.2:27017

Press CTRL-C to terminate port forwarding

打开另一个命令行终端，并使用以下命令从本地机器的mongo命令行客户端连接到 MongoDB 数据库：
```
$ mongo --username <username> --password <password> <host>:<port>/admin
```
将 <username> 和 <password> 替换为您的 MongoDB 插件的用户名和密码。主机和端口值可以在 rhc port-forward 命令的输出中找到。如步骤 1 所示，MongoDB 数据库在 127.0.0.1 主机和 27017 端口上可用。您可以通过运行 rhc show-app 或 rhc cartridge-show mongodb-2.4 命令查看用户名和密码。

连接到 MongoDB 数据库后，您可以执行任何合法命令，如下所示：

> show databases
admin  0.03125GB
local  0.03125GB
myap  (empty)
myapp  0.03125GB
test  0.03125GB

它是如何工作的……

在步骤 1 中，您使用了 rhc port-forward 命令将所有远程端口转发到本地机器。rhc port-forward 命令是 SSH 端口转发的封装器，它使得远程机器上的端口在本地机器上可用。原本无法访问的远程机器上的端口，您可以像访问本地机器上的端口一样使用。该命令返回一个可以从本地机器连接的端口列表，如步骤 1 所示。

如输出所示，mongod 进程可在 27017 端口和 127.0.0.1 主机上访问。

在步骤 2 中，您从本地机器连接到 MongoDB 数据库，传入数据库的用户名、密码、主机和端口。成功连接后，您在步骤 3 中执行了一个命令。

要终止端口转发，只需在运行 rhc port-forward 命令的命令行终端中按下 Ctrl + C。

另见

从本地机器使用 Robomongo 连接到 MongoDB 插件的教程
将 MongoDB 插件添加到您的应用程序的教程

从本地机器使用 Robomongo 连接到 MongoDB 插件

在 从本地机器访问 MongoDB 插件 教程中，您学习了如何使用 mongo 命令行客户端从本地机器连接到 MongoDB 插件。在本教程中，您将学习如何使用 RoboMongo 从本地机器连接到 MongoDB 插件。RoboMongo (robomongo.org/) 是一个开源、跨平台的 MongoDB 图形化管理工具。我们使用 RoboMongo 因为它在所有操作系统上都有支持，并且您可以在 RoboMongo 中输入在 mongo shell 中输入的所有命令。对于习惯使用 mongo shell 的开发者来说，它非常自然。

准备工作

为了完成这个教程，您需要一个带有 MongoDB 插件的应用程序。请参考本章中的 将 MongoDB 插件添加到您的应用程序 教程，了解如何添加 MongoDB 插件。此外，您还需要在本地机器上安装 RoboMongo 工具。您可以从其网站 robomongo.org/ 下载 RoboMongo 工具。

如何操作……

执行以下步骤，通过 RoboMongo 连接到您的 MongoDB 插件：

打开命令行终端，并切换到 myapp 应用程序目录。执行以下命令，将远程端口转发到本地机器：
```
$ rhc port-forward --app myapp
```
启动 RoboMongo 应用程序，你将看到以下截图。点击左上角的连接图标：
点击连接图标后，你将看到一个新窗口，提供创建新连接的选项。点击创建链接以创建新连接：
输入 MongoDB 数据库的详细信息，设置一个新连接。主机和端口可以在第 1 步中rhc port-forward命令的输出中找到，如以下截图所示：
点击身份验证标签，输入连接 MongoDB cartridge 所需的用户名和密码。你可以使用rhc show-app或rhc cartridge-show mongodb-2.4命令查看 MongoDB cartridge 的详细信息。以下截图展示了身份验证标签的详情：
点击保存按钮，你将看到新连接在MongoDB 连接窗口中列出：
点击连接按钮，你将连接到 MongoDB cartridge。
连接到 MongoDB cartridge 后，你可以点击任何数据库并查看其所有集合。当你双击一个集合时，你可以查看其中的前 50 个文档。以下截图展示了msgs集合中的文档：

它是如何工作的…

在步骤 1 中，你使用了rhc port-forward命令将所有远程端口转发到本地机器。这将使得你能够连接到运行在应用程序 gear 中的 MongoDB 数据库。在步骤 2 到 7 中，你创建了一个新的 MongoDB 连接，并从 RoboMongo 内部连接到了 MongoDB cartridge。在步骤 8 中，你导航到了test数据库中的msgs集合。

另见

从本地机器访问 MongoDB cartridge教程
启用 MongoDB cartridge REST 接口教程

启用 MongoDB cartridge REST 接口

MongoDB 提供了一个最小化的 REST 接口，允许用户查询集合。该接口不暴露插入、更新或删除文档的操作。在本教程中，你将学习如何启用 MongoDB cartridge 的 REST 接口。

准备工作

要完成本教程，你需要一个包含 MongoDB cartridge 的应用程序。请参考本章中的将 MongoDB cartridge 添加到应用程序教程，了解如何添加一个 MongoDB cartridge。

如何操作…

按照以下步骤启用 MongoDB REST 接口：

打开一个新的命令行终端，使用ssh命令 SSH 进入myapp应用程序 gear：
```
$ rhc ssh --app myapp
```
进入应用程序 gear 后，切换到mongodb/conf目录，并使用 Vim 编辑mongodb.conf文件。
现在，我们需要将nohttpinterface属性值更新为false，以便 MongoDB 在28017端口启用 HTTP 前端。要启用 REST 接口，您需要添加一个新属性rest，并将其值设置为true，如下所示：
```
nohttpinterface = false
rest = true
```
退出 SSH 会话并重启 MongoDB 组件，以使更改生效：
```
$ rhc cartridge-restart –app mongodb-2.4
```

在本地机器上执行rhc port-forward命令以启用端口转发。这将列出您可以从本地机器连接的所有应用程序。REST 接口将在28017端口暴露：

$ rhc port-forward 
Checking available ports ... done
Forwarding ports ...
Address already in use - bind(2) while forwarding port 8080\. Trying local port 8081

To connect to a service running on OpenShift, use the Local address

Service Local                OpenShift
------- --------------- ---- ----------------
httpd   127.0.0.1:8080   =>  127.2.34.1:8080
httpd   127.0.0.1:8081   =>  127.2.34.3:8080
mongod  127.0.0.1:28017  =>  127.2.34.2:28017
mongodb 127.0.0.1:27017  =>  127.2.34.2:27017

Press CTRL-C to terminate port forwarding

在浏览器中打开http://127.0.0.1:28017/。您需要使用 MongoDB 组件的凭证进行身份验证。它使用 HTTP 基本身份验证。
然后，要查看test文档中msgs集合的所有文档，可以访问http://127.0.0.1:28017/test/msgs/。这将列出一个包含msgs集合中所有消息的 JSON 文档。

工作原理……

默认情况下，MongoDB 禁用了 REST 接口。要启用 REST 接口，您需要更新mongodb.conf MongoDB 配置文件。在第 3 步中，您更新了mongodb.conf文件以启用 REST API。然后，在第 4 步中，您重启了 MongoDB 组件以重新加载配置。为了从本地机器连接到 REST 接口，您在第 5 步启用了端口转发。rhc port-forward命令列出了您可以从本地机器连接的所有远程服务。MongoDB 的 REST 接口可在28017端口访问。在第 7 步中，您通过在浏览器中打开http://127.0.0.1:28017/test/msgs/来查看test数据库中msgs集合的详细信息。

另见

将 MongoLab MongoDB 即服务与 OpenShift 结合使用教程
执行定时 MongoDB 数据库备份教程

执行定时 MongoDB 数据库备份

在本教程中，您将学习如何执行 MongoDB 数据库的定时备份，并将备份上传到 Amazon S3。

准备工作

要完成本教程，您需要一个包含 MongoDB 组件的应用程序。请参阅本章中的将 MongoDB 组件添加到应用程序教程，了解如何安装该组件。同时，您还需要拥有一个 Amazon AWS 账户。如果没有，请访问aws.amazon.com/并注册一个新账户。

如何做……

执行以下步骤以启用 MongoDB 组件的每日定时备份：

访问console.aws.amazon.com/s3/home，并创建一个新的存储桶来存储您的数据库备份。
通过运行以下命令，将cron组件添加到您的应用程序中：
```
$ rhc cartridge-add cron --app myapp
```

使用 SSH 连接到应用程序节点，并在$OPENSHIFT_DATA_DIR中下载s3-bash工具。使用以下命令将其解压到s3-bash目录：

$ rhc ssh --app myapp
$ cd $OPENSHIFT_DATA_DIR
$ wget http://s3-bash.googlecode.com/files/s3-bash.0.02.tar.gz
$ mkdir s3-bash
$ tar -xf s3-bash.0.02.tar.gz -C s3-bash

在$OPENSHIFT_DATA_DIR/s3-bash目录中创建一个名为AWSSecretAccessKeyIdFile的新文件，并将你的 Amazon 密钥访问秘钥存储到其中。这是s3-bash与 Amazon S3 通信所需的。

在本地机器上创建一个脚本，路径为.openshift/cron/minutely/database_backup.sh，并将以下内容添加到其中：

#!/bin/bash
function load_env {
    [ -z "$1" ] && return 1
    [ -f "$1" ] || return 0

    local key=$(basename $1)
    export $key="$(< $1)"
}

for f in ~/.env/mongodb/*
do
  load_env $f
done

set -x
if [ 'date +%H:%M' == "23:50" ]
then
  FILE_NAME=$(date +"%Y%m%d%H%M")
  mongodump --host $OPENSHIFT_MONGODB_DB_HOST --port  $OPENSHIFT_MONGODB_DB_PORT --username $OPENSHIFT_MONGODB_DB_USERNAME --password $OPENSHIFT_MONGODB_DB_PASSWORD --db $OPENSHIFT_APP_NAME --out $OPENSHIFT_DATA_DIR/$FILE_NAME
  cd $OPENSHIFT_DATA_DIR
  zip -r $FILE_NAME.zip $FILE_NAME
  echo "Took MongoDB Dump" >> $OPENSHIFT_CRON_DIR/log/backup.log
  $OPENSHIFT_DATA_DIR/s3-bash/s3-put -k $AWS_ACCESS_KEY_ID -s $OPENSHIFT_DATA_DIR/s3-bash/AWSSecretAccessKeyIdFile -T $OPENSHIFT_DATA_DIR/$FILE_NAME.zip /$AWS_S3_BUCKET/$FILE_NAME.zip
  echo "Uploaded dump to Amazon S3" >> $OPENSHIFT_CRON_DIR/log/backup.log
  rm -f $OPENSHIFT_DATA_DIR/$FILE_NAME.zip
  rm -rf $OPENSHIFT_DATA_DIR/$FILE_NAME
fi

上述脚本将每天在 23:50（11:50 p.m.）运行，并执行mongodump命令以创建数据库备份文件。然后，使用s3-bash API 将文件传输到 Amazon S3。最后，在上传文件后，脚本会从应用程序设备中删除数据库转储文件。
现在，我们需要设置环境变量，以便脚本能够与 Amazon S3 进行通信。如果你不确定如何访问你的安全凭证，可以参考文档：docs.aws.amazon.com/general/latest/gr/getting-aws-sec-creds.html。我们运行以下命令：
```
$ rhc env-set AWS_ACCESS_KEY_ID=< Your Amazon ACCESS_KEY_ID>
$ rhc env-set AWS_S3_BUCKET=<Amazon S3 bucket name >
```
提交代码并推送到 OpenShift 应用。每晚 23:50（11:50 p.m.）时，将进行数据库备份，并将备份文件上传到 Amazon S3。

它是如何工作的……

在第 1 步中，你创建了一个新的 Amazon S3 存储桶，用于存储 MongoDB 数据库备份。Amazon S3 广泛用于存储静态文件，是此任务的理想选择。接下来，你将cron组件添加到应用程序中。cron组件将用于在特定时间执行每日备份。

Amazon S3 暴露了其 REST 服务，用户可以利用这些服务对 S3 存储桶进行操作。Amazon 为多种编程语言提供了包装的 REST API，简化了开发者与应用程序的集成。由于我们希望保持本配方的语言中立，我们使用了 Amazon S3 的 bash 包装器。虽然 Amazon 并未正式支持该包装器，但它的运行效果非常好。在第 3 步中，你通过wget下载了s3-bash工具。tar.gz文件存储在$OPENSHIFT_DATA_DIR中。然后，你解压了该tar.gz文件到s3-bash目录。

接下来，在第 4 步中，你创建了一个名为AWSSecretAccessKeyIdFile的文件，用于存储 Amazon 访问密钥密钥。s3-bash包装器使用该文件作为 AWS 密钥访问秘钥 ID，以避免它出现在使用ps命令查看的运行进程列表中。

在第 5 步中，你创建了一个 bash 脚本，该脚本将在每晚 23:50（11:50 p.m.）执行。脚本首先使用mongodump命令进行数据库备份，然后将文件上传到 Amazon S3。文件名为当前的时间戳。最后，在将备份上传到 S3 后，脚本会删除备份文件，以节省磁盘空间。

第 6 步创建了备份脚本所需的两个环境变量。最后，在第 7 步中，你将代码推送到应用程序设备。

另见

使用 MongoLab MongoDB-as-a-Service 与 OpenShift 配方

使用 MongoLab MongoDB-as-a-Service 与 OpenShift

MongoLab (mongolab.com) 的 MongoDB 服务使你能够轻松地在各种云提供商上设置、操作和扩展 MongoDB 数据库。除了标准的 MongoDB 功能外，MongoLab 还提供以下功能：

在所有主要云提供商上运行 MongoDB，如 Amazon、Google、Rackspace 等
高可用 MongoDB
自动备份
监控支持

在本教程中，你将学习如何将 MongoLab 的 MongoDB 服务与 OpenShift 应用一起使用。

准备开始

要完成这个操作，你需要一个 OpenShift 应用。此外，你还需要一个 MongoLab 账户。如果你还没有账户，请访问 mongolab.com/ 并注册一个新账户。

如何操作…

执行以下步骤，以便从 OpenShift 应用连接到 MongoLab MongoDB 服务器：

创建 MongoLab 账户后，你将看到一个页面，用于创建你的第一个数据库。点击 创建新数据库 按钮：
输入你的 MongoDB 实例的详细信息。在以下截图中，数据库名称为 myapp，而 Amazon EC2 是云托管提供商。我们选择了美国东海岸的数据中心，因为 OpenShift Online 应用实例位于此处。这有助于最小化 OpenShift 应用与数据库实例之间的延迟：
数据库成功创建后，你会看到它被列出，如以下截图所示：
点击 myapp 数据库，你将看到数据库的详细信息：
在你可以连接到数据库之前，你需要创建一个数据库用户。点击 点击这里 链接以创建一个新的数据库用户，如以下截图所示：
这将弹出一个窗口，如以下截图所示，你需要在此输入新数据库用户的用户名和密码：
创建后，数据库用户将在数据库详情页的用户标签下显示。
要连接到 MongoLab MongoDB 实例，你需要在 gear 上安装 mongo 命令行客户端。每个 OpenShift 应用 gear 都已安装了 mongo 命令行客户端，因此你无需执行任何操作。只需使用 rhc ssh 命令 SSH 进入应用 gear，然后输入以下命令。用户名和密码对应于你在第 6 步中创建的凭据。主机、端口和数据库名称对应于第 4 步中找到的信息：
```
$ mongo --host <host> --port <port> --username <username> --password <password> <database_name>
```

一旦连接到 MongoLab MongoDB 实例，你就可以运行任何有效的 MongoDB 命令，如下所示：

> show collections
system.indexes
system.users
> db.msgs.insert({msg:"hello"})
> 
> db.msgs.findOne()
{ "_id" : ObjectId("5315aa28317c39c58ecd4f04"), "msg" : "hello" }

它是如何工作的…

第 1 至第 4 步帮助你创建了一个新的 MongoLab MongoDB 数据库实例。你需要提供与数据库实例相关的详细信息，MongoLab 将根据你输入的详细信息配置一个 MongoDB 数据库实例。从第 5 步到第 7 步，你创建了一个新的数据库用户，使你能够从外部世界连接到 MongoDB 数据库实例。

在第 8 步中，你使用数据库详细信息通过 mongo 命令行客户端连接到 MongoDB 实例，从 OpenShift 应用程序装备进行连接。最后，你在已连接的 MongoLab MongoDB 数据库实例上运行了一些 Mongo 命令。要了解如何使用 PHP 代码连接到 MongoLab，你可以参考 OpenShift 官方博客：www.openshift.com/blogs/getting-started-with-mongodb-mongolab-php-and-openshift。

另请参见

将 MongoDB 卡带添加到你的应用程序 章节

将 MariaDB 卡带添加到你的应用程序

在本节中，你将学习如何将 MariaDB 可下载卡带添加到你的 OpenShift 应用程序。MariaDB (mariadb.org/) 是 MySQL 数据库的社区分支，旨在作为 MySQL 数据库的直接替代。

准备工作

要执行此操作步骤，你需要在你的机器上安装 rhc 命令行客户端。有关详细信息，请参阅第一章中的 安装 OpenShift rhc 命令行客户端 章节，OpenShift 入门。另外，我们将使用在第三章中 使用 rhc 命令行客户端创建 OpenShift 应用程序 章节中创建的应用程序，创建与管理应用程序。

如何操作…

要在 myapp 应用程序上安装 MariaDB 5.5 可下载卡带，打开一个新的命令行终端，然后将目录更改为 myapp 目录的位置，并执行以下命令：

$ rhc cartridge-add https://raw.github.com/openshift-cartridges/mariadb-cartridge/master/metadata/manifest.yml --app myapp

上述命令将会在你的应用程序装备上安装一个新的 MariaDB 服务器实例。

你可以使用 rhc cartridge-s how 命令查看卡带的详细信息：

$ rhc cartridge-show mariadb
developercorey-mariadb-5.5 (MariaDB 5.5)
----------------------------------------
 From:           https://raw.github.com/openshift-cartridges/mariadb-cartridge/master/metadata/manifest.yml
 Gears:          Located with php-5.4, cron-1.4
 Connection URL: mysql://$OPENSHIFT_MARIADB_DB_HOST:$OPENSHIFT_MARIADB_DB_PORT/
 Database Name:  myapp
 Password:       wPG6vvBy6_L9
 Username:       admin7H6WdQN

你还可以使用stop命令停止 MariaDB 服务器：

$ rhc cartridge-stop mariadb

你可以使用restart命令重启 MariaDB 服务器：

$ rhc cartridge-restart mariadb

如果你想从应用程序中移除 MariaDB 服务器，可以使用 remove 命令：

$ rhc cartridge-remove mariadb –-confirm

它是如何工作的…

当你运行rhc cartridge-add命令时，rhc将向 OpenShift 服务器发送一个 HTTP POST 请求。OpenShift 服务器将接收该请求，并使用清单文件为你的应用程序实例化一个新的 MariaDB 服务器实例。在配置好 MariaDB 服务器后，rhc 客户端会在命令行终端显示数据库的详细信息。

你可以通过 SSH 连接到你的应用程序装备，查看 MariaDB 的安装情况：

$ rhc ssh --app myapp

然后，运行 ls 命令查看 gear 目录结构，你将看到 mariadb 目录：

[myapp-osbook.rhcloud.com 52fb71aa5973caf609000026]\> ls -p
app-deployments/  app-root/  cron/  git/  mariadb/  php/

mariadb 目录是你的 mariadb 安装目录，它不会与任何其他 OpenShift 应用程序或用户共享。它仅供你的应用程序使用，只有你的应用程序可以访问它。

你也可以使用 mysql 命令行客户端连接到你的 MariaDB 服务器。我们使用 mysql 客户端，因为它已安装并与 MariaDB 兼容。

现在，你可以对 MariaDB 服务器运行 SQL 命令。要查看所有数据库，运行以下命令：

mysql> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| myapp              |
| mysql              |
+--------------------+
3 rows in set (0.00 sec)

myapp 数据库对应于你的应用程序数据库。

另见

将 MongoDB 组件添加到你的应用程序 的教程

将 Redis 组件添加到你的应用程序

在这个教程中，你将学习如何将 Redis 可下载的组件添加到你的 OpenShift 应用程序中。Redis 是一个开源的先进 NoSQL 键值数据存储系统，使用 ANSI C 编程语言编写。它是一个内存数据存储，但也会写入磁盘以保证数据持久性。

准备就绪

为了执行这个教程，你需要在你的机器上安装 rhc 命令行客户端。有关详细信息，请参考第一章中的 安装 OpenShift rhc 命令行客户端 教程，开始使用 OpenShift。另外，我们将使用在第三章中 使用 rhc 命令行客户端创建 OpenShift 应用程序 教程中创建的应用程序，创建和管理应用程序。

如何操作…

要将 Redis 可下载的组件安装到 myapp 应用程序中，打开一个新的命令行终端，然后切换到 myapp 目录位置，并执行以下命令：

$ rhc cartridge-add http://cartreflect-claytondev.rhcloud.com/reflect?github=smarterclayton/openshift-redis-cart --app myapp

这将在你的应用程序 gear 上安装一个新的 Redis 服务器实例。

你可以使用 rhc cartridge-show 命令查看组件详情。

你也可以使用 stop 命令停止 Redis 服务器：

$ rhc cartridge-stop redis

你可以使用 restart 命令重新启动 Redis 服务器：

$ rhc cartridge-restart redis

如果你想从应用程序中移除 Redis 服务器，可以使用 remove 命令：

$ rhc cartridge-remove redis –-confirm

它是如何工作的…

当你运行 rhc cartridge-add 命令时，rhc 会向 OpenShift 服务器发出 HTTP POST 请求。OpenShift 服务器会接收请求，并根据清单文件为你的应用程序实例化一个新的 Redis 服务器实例。在为 Redis 服务器配置完成后，rhc 客户端将在命令行终端显示数据库详情，如下所示：

Adding http://cartreflect-claytondev.rhcloud.com/reflect?githubgithub=smarterclayton/openshift-redis-cart to application 'myapp' ... done

smarterclayton-redis-2.6 (Redis)
--------------------------------
 From:  http://cartreflect-claytondev.rhcloud.com/reflect?github=smarterclayton/openshift-redis-cart
 Gears: Located with php-5.4

Redis is now configured with a default password ZTNiMGM0NDI5OGZjMWMxNDlhZmJmNGM4OTk2ZmI5
You can configure various Redis scaling and persistence modes by setting
environment variables - consult the cartridge README for more info.

你可以通过 SSH 登录到你的应用程序 gear 来查看 Redis 的安装情况：

$ rhc ssh --app myapp

然后，运行 ls 命令查看 gear 目录结构，你将看到 redis 目录：

[myapp-osbook.rhcloud.com 52fb71aa5973caf609000026]\> ls -p
app-deployments/  app-root/  git/  php/  redis/

redis 目录是你的 redis 安装目录，它不会与任何其他 OpenShift 应用程序或用户共享。它仅供你的应用程序使用，只有你的应用程序可以访问它。

你也可以使用 redis-cli 命令行客户端连接到你的 Redis 服务器：

[myapp-osbook.rhcloud.com 53121c645973ca7acf000018]\> redis-cli $REDIS_CLI 
redis 127.2.34.2:16379>

现在，你可以对 Redis 服务器执行命令。要查看有关你的 Redis 安装的详细信息，可以运行 INFO 命令：

redis 127.2.34.2:16379> INFO
# Server
redis_version:2.6.13
redis_git_sha1:00000000
redis_git_dirty:0
redis_mode:standalone
os:Linux 2.6.32-431.5.1.el6oso.bz844450.x86_64 x86_64
arch_bits:64
multiplexing_api:epoll
tcp_port:16379
uptime_in_seconds:874
uptime_in_days:0
hz:10
lru_clock:957695
// removed for brevity

这还不是全部…

想了解如何在 Java 应用程序中使用 Redis，可以阅读我在 www.openshift.com/blogs/build-cloud-enabled-java-redis-applications-with-spring-on-openshift 的博客。

另见

将 MariaDB 载入你的应用程序 的方法

第七章：OpenShift for Java 开发者

本章介绍了一些示例，展示如何在 OpenShift 上开始 Java Web 应用程序开发。你将学习如何使用 JBoss EAP 6 和 JBoss AS 7 应用程序服务器组件，在 OpenShift 上创建和部署Java 企业版 (Java EE) 应用程序。本章还将涵盖如何在 Tomcat 服务器上开发和托管 Spring 框架应用程序。本章的具体示例如下：

使用 JBoss EAP 和 PostgreSQL 9.2 组件创建并部署 Java EE 6 应用程序
通过在 standalone.xml 中定义数据库登录模块来配置应用程序安全性
使用 JBoss 组件安装模块
使用管理 Web 界面和 CLI 管理 JBoss 组件
使用 Tomcat 7 组件创建并部署 Spring 应用程序
获取 Java 组件的线程转储
在 Java 6 和 Java 7 之间进行选择
为 Java 应用程序启用热部署
跳过 Maven 构建
强制进行干净的 Maven 构建
重写默认的 Maven 构建命令
安装在 Maven 中央仓库中没有的 JAR 文件
使用 Eclipse 开发 OpenShift Java 应用程序
使用 Eclipse 系统资源管理器通过 SSH 连接到应用程序设备
在云中调试 Java 应用程序

简介

本章将探讨 Java 开发者如何使用 OpenShift 开始开发 Java EE 或 Spring 应用程序。Java 通常被认为是事实上的开源企业编程语言。OpenShift 支持 JBoss 应用程序服务器，这是 Java EE 6 开发的认证平台。作为 OpenShift Online 用户，你可以免费使用 JBoss 社区版和商业版 JBoss EAP 6。使用 JBoss EAP 和 PostgreSQL 9.2 组件创建并部署 Java EE 6 应用程序 的示例将展示如何在 OpenShift 上开发和部署 Java EE 6 应用程序。此外，OpenShift 还支持 WildFly 组件，这是一个认证的 Java EE 7 应用程序服务器，你可以使用它来部署 Java EE 7 应用程序。本章不会讨论 WildFly 组件。

一个流行的 Java EE 开发替代方案是 Spring 框架。Spring 开发者通常使用 Apache Tomcat 来托管他们的应用程序。OpenShift 支持两个版本的 Tomcat：Apache Tomcat 6 和 Apache Tomcat 7。使用 Tomcat 7 组件创建并部署 Spring 应用程序 的示例将展示如何开发一个 Spring 应用程序并将其部署到 OpenShift。同时，OpenShift 也可以运行 Apache Tomcat 8（目前处于测试阶段）。你可以阅读我的博客，了解如何在 OpenShift 上部署 Apache Tomcat 8，链接：www.openshift.com/blogs/how-to-run-apache-tomcat-8-on-openshift。

OpenShift 使用 Apache Maven 来管理依赖并构建你的 OpenShift 应用程序。所有 OpenShift Java 应用程序都是基于 Maven 的应用程序。本章假设你已熟悉 Apache Maven。如果你对 Maven 不太熟悉，请参考maven.apache.org/guides/getting-started/index.html的文档。本章将涉及使用 Apache Maven 与 OpenShift 配合的各个方面，例如如何将你自己的 JAR（非托管于 Maven 中央仓库）与 OpenShift 一起使用等。OpenShift 还允许你使用其他构建工具，如 Apache Ant 和 Gradle。请参考我的博客，了解如何将 Apache Ant（www.openshift.com/blogs/running-ant-builds-on-openshift）和 Gradle（www.openshift.com/blogs/run-gradle-builds-on-openshift）与 OpenShift 应用程序一起使用。

几乎所有的 Java 开发者都会使用 IDE 来构建他们的应用程序。OpenShift 对 Eclipse IDE 提供了一流的支持。使用 Eclipse 开发 OpenShift Java 应用程序这一章节将带你逐步完成从 Eclipse 内创建和管理应用程序的过程。你甚至可以直接从 Eclipse 内 SSH 连接到应用程序的 Gear 中。这将在使用 Eclipse 系统资源管理器通过 SSH 连接到应用程序 Gear的章节中进行讲解。

如果你想在本地机器上运行示例，请安装 Java 7、Apache Maven 和 Eclipse。你可以在www.java.com/en/download/help/download_options.xml找到针对你的操作系统安装 Java 的说明。接下来，关于安装 Apache Maven 的说明可以在此找到：maven.apache.org/download.cgi#Installation。最后，你可以按照此处的说明安装 Eclipse：wiki.eclipse.org/Eclipse/Installation。

本章节假设你已经了解 OpenShift 应用程序开发和数据库 Cartridge 的基础。如果你对这些基础不太熟悉，建议你先阅读第三章，创建与管理应用程序，然后阅读第六章，使用 MongoDB 和第三方数据库 Cartridge 与 OpenShift 应用程序，再继续本章内容。

在本章中，我们将开发一个简单的职位门户应用程序，允许用户为公司发布职位空缺。用户可以创建公司并为该公司发布职位。所有源代码都可以在 GitHub 组织的 OpenShift-Cookbook 仓库中找到，地址是 github.com/OpenShift-Cookbook。

使用 JBoss EAP 和 PostgreSQL 9.2 cartridge 创建和部署 Java EE 6 应用程序

曾几何时，Java EE 或 J2EE（在过去的日子里是这么称呼的）被视为邪恶的存在。如今，Java EE 提供了一个非常高效的环境来构建 Web 应用程序。Java EE 已经拥抱了“约定优于配置”和注解，这意味着你不再需要维护 XML 来配置每一个组件。在本篇教程中，你将学习如何构建一个 Java EE 6 应用程序，并将其部署到 OpenShift。此教程假定你具备 Java 和 Java EE 6 的基础知识。如果你对 Java EE 6 不熟悉，请阅读官方教程，网址是 docs.oracle.com/javaee/6/tutorial/doc/。

在本教程中，你将构建一个简单的职位门户，允许用户发布职位空缺，并查看系统中所有已保存职位的列表。这两个功能将通过两个 REST 端点暴露出来。

本教程中创建的应用程序的源代码可在 GitHub 上找到，地址是 github.com/OpenShift-Cookbook/chapter7-jobstore-javaee6-simple。你将在本教程中构建的示例应用程序是 jobstore 应用程序的简化版本，只有一个域类，并且没有任何应用程序界面。你也可以在 GitHub 上找到完整的 jobstore 应用程序源代码，地址是 github.com/OpenShift-Cookbook/chapter7-jobstore-javaee6。

准备工作

为了完成本教程，你需要在机器上安装 rhc 命令行客户端。有关详细信息，请参阅第一章中的 安装 OpenShift rhc 命令行客户端 教程，标题为 开始使用 OpenShift。此外，你还需要一个 IDE 来处理应用程序代码。推荐使用的 IDE 是 Eclipse Luna，但你也可以使用其他 IDE，如 IntelliJ Idea 和 NetBeans。从官方网站下载并安装适用于 Java EE 开发者的 Eclipse IDE，网址是 www.eclipse.org/downloads/。

操作步骤...

执行以下步骤以创建 jobstore 应用程序：

打开一个新的命令行终端，并进入一个方便的位置。通过执行以下命令创建一个新的 JBoss EAP 应用程序：
```
$ rhc create-app jobstore jbosseap-6
```
上述命令将创建一个 Maven 项目并将其克隆到你的本地机器。
将目录更改为jobstore，然后执行以下命令将 PostgreSQL 9.2 cartridge 添加到应用程序中：
```
$ rhc cartridge-add postgresql-9.2
```
打开 Eclipse 并导航到项目工作空间。然后，将步骤 1 中创建的应用程序作为 Maven 项目导入。要导入现有的 Maven 项目，请导航至文件|导入|Maven|现有的 Maven 项目。然后，导航到您在步骤 1 中创建的 OpenShift Maven 应用程序的位置。
接下来，更新pom.xml以使用 Java 7。OpenShift 创建的 Maven 项目配置为使用 JDK 6。请使用以下代码替换属性：
```
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
```
更新 Maven 项目以使更改生效。可以右键单击项目，然后导航至Maven|更新项目。

现在，让我们编写应用程序的领域类。Java EE 使用 JPA 定义数据模型并管理实体。应用程序有一个领域类：Job。创建一个名为org.osbook.jobstore.domain的新包，然后在其中创建一个名为Job的新 Java 类。请查看以下代码：

@Entity
public class Job {

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;

@NotNull
private String title;

@NotNull
@Size(max = 4000)
private String description;

@Column(updatable = false)
@Temporal(TemporalType.DATE)
@NotNull
private Date postedAt = new Date();

@NotNull
private String company;

//setters and getters removed for brevity

}

在src/main/resources下创建一个META-INF文件夹，然后创建一个名为persistence.xml的文件，其中包含以下代码：

<?xml version="1.0" encoding="UTF-8"?>
<persistence 
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
version="2.0">

<persistence-unit name="jobstore" transaction-type="JTA">
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<jta-data-source>java:jboss/datasources/PostgreSQLDS</jta-data-source>

<exclude-unlisted-classes>false</exclude-unlisted-classes>

<properties>
<property name="hibernate.show_sql" value="true" />
<property name="hibernate.hbm2ddl.auto"value="update" />
</properties>
</persistence-unit>

</persistence>

现在，我们将创建JobService类，该类将使用 JPA EntityManager API 与数据库交互。创建一个名为org.osbook.jobstore.services的新包，并创建一个新的 Java 类，如下所示。它定义了Job实体上的save和findAll操作。

@Stateless
public class JobService {

@PersistenceContext(unitName = "jobstore")
private EntityManager entityManager;

public Job save(Job job) {
entityManager.persist(job);
return job;
}

public List<Job> findAll() {
return entityManager
.createQuery("SELECT j from org.osbook.jobstore.domain.Job j order by j.postedAt desc", Job.class)
.getResultList();
}
}

接下来，在jobstore应用程序中通过在src/main/webapp/WEB-INF目录下创建一个名为beans.xml的文件来启用上下文和依赖注入（CDI），如下所示：
```
<?xml version="1.0"?>
<beans 
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://jboss.org/schema/cdi/beans_1_0.xsd"/>
```
jobstore应用程序将公开 REST JSON web 服务。在编写 JAX-RS 资源之前，您必须在应用程序中配置 JAX-RS。创建一个名为org.osbook.jobstore.rest的新包和一个名为RestConfig的新类，如下所示：
```
@ApplicationPath("/api/v1")
public class RestConfig extends Application {
}
```

创建 JAX-RS 资源以暴露JobService的create和findAll操作作为 REST 端点，如下所示：

@Path("/jobs")
public class JobResource {

@Inject
private JobService jobService;

@POST
@Consumes(MediaType.APPLICATION_JSON)
public Response createNewJob(@Valid Job job) {
job = jobService.save(job);
return Response.status(Status.CREATED).build();
}

@GET
@Produces(MediaType.APPLICATION_JSON)
public List<Job> showAll() {
return jobService.findAll();
}
}

如下所示提交代码，并将其推送到 OpenShift 应用程序中：

$ git add .
$ git commit -am "jobstore application created"
$ git push

构建成功完成后，应用程序将在http://jobstore-{domain-name}.rhcloud.com上访问。请将domain-name替换为您自己的域名。

要测试 REST 端点，可以使用curl。curl是一个用于跨各种协议传输数据的命令行工具。我们将使用它来测试我们的 REST 端点。要创建一个新作业，您将运行以下curl命令：

$ curl -i -X POST -H "Content-Type: application/json" -H "Accept: application/json" -d '{"title":"OpenShift Evangelist","description":"OpenShift Evangelist","company":"Red Hat"}'http://jobstore-{domain-name}.rhcloud.com/api/v1/jobs

要查看所有作业，可以运行以下curl命令：

$ curl http://jobstore-{domain-name}.rhcloud.com/api/v1/jobs

工作原理...

在前面的步骤中，我们创建了一个 Java EE 应用程序并将其部署到 OpenShift。在步骤 1 中，你使用rhc create-app命令创建了一个 JBoss EAP Web 卡片应用程序。rhc命令行工具向 OpenShift 代理发出请求，要求它使用 JBoss EAP 卡片创建一个新应用程序。应用程序创建的结构在第三章的使用 rhc 命令行客户端创建 OpenShift 应用程序一节中进行了说明，创建和管理应用程序。每个 OpenShift Web 卡片都会指定一个模板应用程序，用作应用程序的默认源代码。对于 Java Web 卡片（JBoss EAP、JBoss AS7、Tomcat 6 和 Tomcat 7），模板是一个基于 Maven 的应用程序。应用程序创建后，它会通过 Git 克隆到本地机器。应用程序的目录结构如下所示：

$ ls -a
.git .openshift README.md pom.xml deployments src

正如在前面的命令中所看到的，除了.git和.openshift目录外，这看起来像一个标准的 Maven 项目。OpenShift 使用 Maven 来管理应用程序的依赖关系并构建你的 Java 应用程序。

让我们看一下jobstore目录中的内容，以更好地了解应用程序的布局：

src 目录：该目录包含由 OpenShift 生成的模板应用程序的源代码。你需要在这里添加你的应用程序源代码。src文件夹有助于按照标准 Maven 目录约定实现源代码的部署。
pom.xml 文件：由 OpenShift 创建的 Java 应用程序是基于 Maven 的项目。因此，在 OpenShift 上进行源代码部署时需要一个pom.xml文件。此pom.xml文件有一个名为openshift的配置文件，当你将代码推送到 OpenShift 时，将执行此配置文件，如以下代码所示。此配置文件将基于你的应用程序源代码创建一个ROOT WAR 文件。
```
<profiles>
<profile>
<id>openshift</id>
<build>
<finalName>jobstore</finalName>
<plugins>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>2.1.1</version>
<configuration>
<outputDirectory>deployments</outputDirectory>
<warName>ROOT</warName>
</configuration>
</plugin>
</plugins>
</build>
</profile>
</profiles>
```
deployments 目录：如果你想在 OpenShift 上进行二进制部署，即直接部署 WAR 或 EAR 文件而不是推送源代码，你应该使用此目录。
.git 目录：这是一个本地 Git 仓库。该目录包含仓库的完整历史记录。.git/中的config文件包含仓库的配置。它定义了指向 OpenShift 应用程序齿轮 SSH URL 的 Git 远程源。这确保了当你执行git push时，源代码会被推送到托管在应用程序齿轮上的远程 Git 仓库。你可以通过执行以下命令查看远程 Git 源的详细信息：
```
$ git remote show origin
```
.openshift 目录：这是一个 OpenShift 特有的目录，可以用于以下目的：
- action_hooks子目录下的文件允许你挂钩到应用程序生命周期中。
- config子目录下的文件允许你对 JBoss EAP 配置进行更改。该目录包含 JBoss EAP 特定的配置文件standalone.xml。
- cron子目录下的文件在你将 cron 卡带添加到应用程序时使用。这使得你可以定期运行脚本或作业。
- markers子目录下的文件允许你指定是否使用 Java 6 或 Java 7，或者你是否希望进行热部署或调试在云端运行的应用程序等操作。

在第 2 步中，你使用rhc cartridge-add命令将 PostgreSQL 9.2 卡带添加到应用程序中。我们将使用 PostgreSQL 数据库来存储jobstore应用程序的数据。接着，在第 3 步中，你将项目作为 Maven 项目导入到 Eclipse IDE 中。Eclipse Kepler 内置对 Maven 应用程序的支持，这使得使用基于 Maven 的应用程序更加方便。

从第 3 步到第 5 步，你更新了项目，以使用 JDK 1.7 作为 Maven 编译插件的编译器。所有的 OpenShift Java 应用程序都使用 OpenJDK 7，因此更新应用程序以使用 JDK 1.7 进行编译是合乎逻辑的。

在第 6 步中，你创建了job领域类并使用 JPA 注解对其进行了标注。@Entity注解将该类标记为 JPA 实体类。实体类表示关系型数据库中的一张表，每个实体实例对应表中的一行。实体类的字段表示实体的持久化状态。你可以通过阅读docs.oracle.com/javaee/6/tutorial/doc/bnbpz.html上的官方文档，了解更多关于 JPA 的内容。

@NotNull和@Size注解是 Bean 验证注解。Bean 验证是 Java EE 6 平台中的一种新验证模型。@NotNull注解添加了一个约束，要求字段的值不能为空。如果值为 null，则会引发异常。@Size注解添加了一个约束，要求值符合指定的最小值和最大值边界。你可以通过阅读docs.oracle.com/javaee/6/tutorial/doc/gircz.html上的官方文档，了解更多关于 Bean 验证的内容。

在 JPA 中，实体在持久化上下文中进行管理。在持久化上下文中，实体管理器管理实体。实体管理器的配置在一个标准的配置 XML 文件 persistence.xml 中定义。在第 7 步中，你创建了 persistence.xml 文件。最重要的配置选项是 jta-datasource-source 配置标签，它指向 java:jboss/datasources/PostgreSQLDS。当用户创建 JBoss EAP 6 应用程序时，OpenShift 会在 standalone.xml 文件中定义一个 PostgreSQL 数据源。standalone.xml 文件是一个 JBoss 配置文件，包含 Java EE 6 完整规范所需的技术以及 Java Connector 1.6 架构、Java XML API 用于 RESTful Web 服务和 OSGi。开发人员可以通过更改应用程序目录中 .openshift/config 位置的 standalone.xml 文件来覆盖配置。因此，如果你在你喜欢的编辑器中打开 .openshift/config/ 中的 standalone.xml 文件，你会发现以下 PostgreSQL 数据源配置：

<datasource jndi-name="java:jboss/datasources/PostgreSQLDS"
enabled="${postgresql.enabled}" use-java-context="true" pool-name="PostgreSQLDS"
use-ccm="true">
<connection-url>jdbc:postgresql://${env.OPENSHIFT_POSTGRESQL_DB_HOST}:${env.OPENSHIFT_POSTGRESQL_DB_PORT}/${env.OPENSHIFT_APP_NAME}
</connection-url>
<driver>postgresql</driver>
<security>
<user-name>${env.OPENSHIFT_POSTGRESQL_DB_USERNAME}</user-name>
<password>${env.OPENSHIFT_POSTGRESQL_DB_PASSWORD}</password>
</security>
<validation>
<check-valid-connection-sql>SELECT 1</check-valid-connection-sql>
<background-validation>true</background-validation>
<background-validation-millis>60000</background-validation-millis>
<!--<validate-on-match>true</validate-on-match> -->
</validation>
<pool>
<flush-strategy>IdleConnections</flush-strategy>
<allow-multiple-users />
</pool>
</datasource>

在第 8 步中，你为我们的应用程序服务层创建了无状态的 企业 JavaBeans (EJBs)。服务类通过 EntityManager API 对 Job 实体进行操作。

在第 9 步中，你通过在 src/main/webapp/WEB-INF 目录下创建 beans.xml 文件来配置 CDI。我们在应用程序中使用 CDI，以便能够使用依赖注入，而不是手动创建对象。CDI 容器将管理 bean 的生命周期，开发人员只需编写业务逻辑。为了让 JBoss 应用服务器知道我们在使用 CDI，我们需要在 WEB-INF 目录下创建一个名为 beans.xml 的文件。该文件可以完全为空，但它的存在告诉容器需要加载 CDI 框架。

在第 10 步和第 11 步中，你配置了 JAX-RS 并定义了 Job 实体的 REST 资源。你通过创建一个扩展 javax.ws.rs.ApplicationPath 的类来激活 JAX-RS。你需要指定一个基本 URL，供你的 Web 服务使用。你通过为 RestConfig 类添加 ApplicationPath 注解来完成此操作。你使用 /api/v1 作为应用程序路径。

在第 12 步中，你将更改添加并提交到本地仓库，然后将更改推送到应用程序 gear。位文件推送后，OpenShift 会停止所有卡带，然后调用 mvn -e clean package -Popenshift -DskipTests 命令来构建项目。Maven 会构建一个 ROOT.war 文件，并将其复制到 JBoss EAP 的 deployments 文件夹。构建成功完成后，所有卡带都会启动。然后，新的更新的 ROOT.war 文件将被部署。你可以通过 http://jobstore-{domain-name}.rhcloud.com 查看运行中的应用程序。请将 {domain-name} 替换为你的账户域名。

最后，您在第 14 步使用 curl 测试了 REST 端点。

另请参见

通过在 standalone.xml 中定义数据库登录模块配置应用安全性 配方
使用管理 Web 界面和 CLI 管理 JBoss 套件 配方

通过在 standalone.xml 中定义数据库登录模块配置应用安全性

在 使用 JBoss EAP 和 PostgreSQL 9.2 套件创建和部署 Java EE 6 应用 配方中，您学会了如何在 OpenShift 上开发 Java EE 6 应用。该应用允许您创建公司实体并为其分配职位。此应用的问题在于它没有安全设置。Java EE 规范定义了一种简单的基于角色的安全模型，用于 EJB 和 Web 组件。JBoss 安全性是应用服务器的扩展，并默认包含在 OpenShift JBoss 应用中。您可以在 JBoss standalone.xml 配置文件中查看该扩展。standalone.xml 文件位于 .openshift/config 位置。以下代码展示了该扩展：

<extension module="org.jboss.as.security" />

OpenShift 允许开发人员更新 standalone.xml 配置文件以满足其应用需求。您修改 standalone.xml 配置文件后，将更改提交到本地 Git 仓库，并将更改推送到 OpenShift 应用服务器。然后，在成功构建后，OpenShift 会用您更新的配置文件替换现有的 standalone.xml 文件，并最终启动服务器。但请确保您的更改是有效的，否则应用将无法启动。

在本配方中，您将学习如何在 standalone.xml 中定义数据库登录模块，以便在用户进行任何操作之前对其进行身份验证。

本配方中创建的应用的源代码可以在 GitHub 上找到：github.com/OpenShift-Cookbook/chapter7-jobstore-security。

准备就绪

此配方基于 使用 JBoss EAP 和 PostgreSQL 9.2 套件创建和部署 Java EE 6 应用 配方中的应用。请在继续此配方之前参考该配方。

如何操作…

执行以下步骤为您的 Web 应用添加安全性：

使用以下命令创建 使用 JBoss EAP 和 PostgreSQL 9.2 套件创建和部署 Java EE 6 应用 配方中的 OpenShift 应用：

$ rhc create-app jobstore jbosseap postgresql-9.2 --from-code https://github.com/OpenShift-Cookbook/chapter7-jobstore-javaee6-simple.git --timeout 180

创建应用后，使用 SSH 进入应用服务器，并通过 psql 客户端连接 PostgreSQL 数据库。然后，创建以下表格并插入测试数据：

$ rhc ssh
$ psql
jobstore=# CREATE TABLE USERS(email VARCHAR(64) PRIMARY KEY, password VARCHAR(64));
jobstore=# CREATE TABLE USER_ROLES(email VARCHAR(64), role VARCHAR(32));
jobstore=# INSERT into USERS values('admin@jobstore.com', 'ISMvKXpXpadDiUoOSoAfww==');
jobstore=# INSERT into USER_ROLES values('admin@jobstore.com', 'admin');

退出 SSH shell，打开 .openshift/config 目录中的 standalone.xml 文件。使用以下代码更新安全域：

<security-domain name="other" cache-type="default">
<authentication>
<login-module code="Remoting" flag="optional">
<module-option name="password-stacking"value="useFirstPass" />
</login-module>
<login-module code="Database" flag="required">
<module-option name="dsJndiName"
value="java:jboss/datasources/PostgreSQLDS" />
<module-option name="principalsQuery"
value="select password from USERS where email=?" />
<module-option name="rolesQuery"
value="select role, 'Roles' from USER_ROLES where email=?" />
<module-option name="hashAlgorithm" value="MD5" />
<module-option name="hashEncoding" value="base64" />
</login-module>
</authentication>
</security-domain>

在src/main/webapp/WEB-INF文件夹中创建 web 部署描述符（即web.xml）。将以下内容添加到该文件中：

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">

<security-constraint>
<web-resource-collection>
<web-resource-name>WebAuth</web-resource-name>
<description>application security constraints
</description>
<url-pattern>/*</url-pattern>
<http-method>GET</http-method>
<http-method>POST</http-method>
</web-resource-collection>
<auth-constraint>
<role-name>admin</role-name>
</auth-constraint>
</security-constraint>
<login-config>
<auth-method>FORM</auth-method>
<realm-name>jdbcRealm</realm-name>
<form-login-config>
<form-login-page>/login.html</form-login-page>
<form-error-page>/error.html</form-error-page>
</form-login-config>
</login-config>
<security-role>
<role-name>admin</role-name>
</security-role>

</web-app>

在src/main/webapp目录中创建login.html文件。login.html页面将用于用户身份验证。以下代码显示了该文件的内容：

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Login</title>
<link href="//cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.1.1/css/bootstrap.css" rel="stylesheet">
</head>
<body>
<div class="container">
<form class="form-signin" role="form" method="post"action="j_security_check">
<h2 class="form-signin-heading">Please sign in</h2>
<input type="text" id="j_username"name="j_username" class="form-control" placeholder="Email address" required autofocus>
<input type="password" id="j_password"name="j_password" class="form-control"placeholder="Password" required>
<button class="btn btn-lg btn-primary btn-block"type="submit">Sign in</button>
</form>
</div>
</body>
</html>

在src/main/webapp目录中创建一个error.html文件。error.html页面将在身份验证失败后显示。以下代码显示了该文件的内容：
```
<!DOCTYPE html>
<html>
<head>
<meta charset="US-ASCII">
<title>Error page</title>
</head>
<body>
<h2>Incorrect username/password</h2>
</body>
</html>
```

提交更改并将其推送到 OpenShift 应用程序 Gear：

$ git add .
$ git commit –am "enabled security"
$ git push

访问应用程序页面http://jobstore-{domain-name}.rhcloud.com，系统会要求您登录才能查看应用程序。使用admin@jobstore.com/admin作为用户名-密码组合登录应用程序。

它是如何工作的…

现在让我们理解您在前面步骤中做了什么。在第 1 步中，您重新创建了我们在使用 JBoss EAP 和 PostgreSQL 9.2 Cartridge 创建和部署 Java EE 6 应用程序配方中开发的jobstore应用程序。接下来，在第 2 步中，您通过 SSH 连接到应用程序 Gear，并创建了USERS和USER_ROLES表。这些表将由 JBoss 数据库登录模块用于身份验证。由于我们的应用程序没有用户注册功能，我们为该应用程序创建了一个默认用户。以明文字符串存储密码是一个不好的做法，因此我们存储了密码的 MD5 哈希值。admin密码的 MD5 哈希值是ISMvKXpXpadDiUoOSoAfww==。如果您想在应用程序中生成哈希密码，我已经包含了一个简单的 Java 类，使用org.jboss.crypto.CryptoUtil生成任意字符串的 MD5 哈希值。CryptoUtil类是picketbox库的一部分。以下代码展示了这一点：

import org.jboss.crypto.CryptoUtil;

public class PasswordHash {

public static String getPasswordHash(String password) {
return CryptoUtil.createPasswordHash("MD5", CryptoUtil.BASE64_ENCODING,
null, null, password);
}

public static void main(String[] args) throws Exception {
System.out.println(getPasswordHash("admin"));
}
}

在第 3 步中，您退出了 SSH 会话，并更新了standalone.xml JBoss 配置文件，加入了数据库登录模块的配置。现成的有多个登录模块实现。本书只会讨论数据库登录模块，其他模块的讨论超出了本书的范围。您可以在docs.jboss.org/author/display/AS7/Security+subsystem+configuration查看所有登录模块的文档。数据库登录模块会将用户凭证与关系数据库进行比对。为了配置数据库登录模块，您需要指定一些配置选项。dsJndiName选项用于指定应用程序的数据源。由于我们为应用程序配置了 PostgreSQL 数据源，因此您指定了相同的dsJndiName选项值。接下来，您需要指定用于获取用户及其角色的 SQL 查询。然后，您指定密码将通过 MD5 哈希算法进行加密，这可以通过指定hashAlgorithm配置来实现。

在第 4 步中，你通过在web.xml中定义安全约束，将数据库登录模块应用到jobstore应用程序中。此配置将对应用程序的所有 Web 资源添加安全约束，限制只有具有 admin 角色的已认证用户才能访问。你还配置了应用程序使用基于表单的认证。这将确保当未认证的用户访问网站时，他们会被重定向到第 5 步中创建的login.html页面。如果用户输入错误的电子邮件/密码组合，则会被重定向到第 6 步中创建的error.html页面。

最后，在第 7 步中，你将更改提交到本地 Git 仓库，并将更改推送到应用程序设备。OpenShift 将确保 JBoss EAP 应用服务器使用更新后的standalone.xml配置文件。现在，用户将被要求进行身份验证，然后才能使用该应用程序。

另见

使用 JBoss EAP 和 PostgreSQL 9.2 cartridges 创建和部署 Java EE 6 应用程序食谱
使用 JBoss cartridges 安装模块食谱
使用管理 Web 界面和 CLI 管理 JBoss cartridges食谱

使用 JBoss cartridges 安装模块

从 JBoss 应用服务器 7 版本开始，类加载基于 JBoss Modules 项目。在此食谱中，你将学习如何在 JBoss EAP 6 cartridge 上将Twitter4J库作为模块安装。JBoss 服务器主目录下的modules目录包含了所有安装在应用服务器上的模块。

本食谱中创建的应用程序的源代码托管在 GitHub 上，链接为github.com/OpenShift-Cookbook/chapter7-recipe4。

准备工作

本食谱基于使用 JBoss EAP 和 PostgreSQL 9.2 cartridges 创建和部署 Java EE 6 应用程序食谱中创建的应用程序。因此，请在继续本食谱之前，先参考该食谱。

如何操作……

执行以下步骤，将Twitter4J库作为模块安装：

使用以下命令创建在使用 JBoss EAP 和 PostgreSQL 9.2 cartridges 创建和部署 Java EE 6 应用程序食谱中创建的 OpenShift 应用程序：
```
$ rhc app-create jobstore jbosseap postgresql-9.2 --from-code https://github.com/OpenShift-Cookbook/chapter5-jobstore-javaee6.git --timeout 180
```
要安装新模块，必须在.openshift/config/modules目录下创建模块路径，如下所示：
```
$ mkdir –p .openshift/config/modules/org/twitter4j/main
```
从mvnrepository.com/artifact/org.twitter4j/twitter4j-core/3.0.5下载twitter4j-core库，并将其放置在.openshift/config/modules/org/twitter4j/main目录下。

现在，在main文件夹中，添加一个名为module.xml的文件。该文件包含实际的模块定义，如下所示：

<module  name="org.twitter4j">
<resources>
<resource-root path="twitter4j-core-3.0.5.jar" />
</resources>
<dependencies>
<module name="javax.api"/>
</dependencies>
</module>

现在，要在你的应用程序中使用这个模块，首先必须在pom.xml文件中添加它的依赖。确保作用域为 provided，因为服务器已经拥有这个依赖，因为你是将其作为模块添加的：
```
<dependency>
<groupId>org.twitter4j</groupId>
<artifactId>twitter4j-core</artifactId>
<version>3.0.5</version>
<scope>provided</scope>
</dependency>
```

其次，你需要通过在META-INF/MANIFEST.MF位置添加org.twitter4j模块依赖来更新 Maven WAR 插件配置：

<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>2.4</version>
<configuration>
<archive>
<manifestEntries>
<Dependencies>org.twitter4j</Dependencies>
</manifestEntries>
</archive>
<outputDirectory>deployments</outputDirectory>
<warName>ROOT</warName>
<failOnMissingWebXml>false</failOnMissingWebXml>
</configuration>
</plugin>

最后，提交更改并将其推送到应用程序 gear。现在，服务器重启后，JBoss 将把twitter4j库作为模块加载。

它是如何工作的…

在前面的步骤中，你学习了如何将第三方库安装为模块。使用第三方库的替代方法是，在pom.xml中添加一个编译作用域的依赖，然后在应用程序中使用twitter4j库。使用模块的优势在于你不需要将 JAR 文件与应用程序归档一起打包。如果你在单个服务器实例上部署多个应用程序，那么服务器只需要一个 JAR 文件的副本。

在第一步创建应用程序后，你在第二步创建了所需的目录结构，以在.openshift/config目录中定义一个模块。这个目录被添加到与你的 OpenShift 应用程序关联的 JBoss EAP 服务器的模块路径中。它与标准的 JBoss EAP modules目录结构相同。在org.twitter4j.main目录中，你在第三步放置了twitter4j-core-3.0.5.jar文件。在第四步，你在org.twitter4j.main目录中创建了一个名为module.xml的文件。module.xml文件用于定义一个模块及其依赖关系。模块名称org.twitter4j对应于你将在应用程序清单中定义的模块属性。接下来，你需要声明twitter4j-core库的路径，最后是它的依赖关系。

接下来，在第五步，你将twitter4j-core库添加为提供作用域的依赖。提供作用域表示你期望应用程序容器在运行时提供该依赖。此外，提供的依赖不会与 Web 应用程序一起打包。这确保了应用程序归档的体积更小，应用程序的部署速度更快。此外，在第五步，你更新了 Maven WAR 插件配置，以将对org.twitter4j模块的依赖添加到应用程序归档的META-INF/MANIFEST.MF文件中。

在第六步，你提交了更改并将其推送到应用程序 gear。

在这个食谱中，我没有涉及如何使用Twitter4J库。如果您想看到Twitter4J的实际操作，我为您创建了一个应用程序，它将在每次发布职位后发送一条推文。要使用该应用程序，您首先需要创建一个 Twitter 应用程序。请访问dev.twitter.com，并创建一个新的 Twitter 应用程序。为应用程序提供读写权限。完成后，运行以下命令创建一个新的 OpenShift 应用程序。请将环境变量的值替换为您自己 Twitter 应用程序的值。您可以在 Twitter 应用程序的API Keys部分找到这些值。

$ rhc create-app jobstore jbosseap postgresql-9.2 --env TWITTER_CONSUMER_KEY=$TWITTER_CONSUMER_KEY TWITTER_CONSUMER_SECRET=$TWITTER_CONSUMER_SECRET TWITTER_ACCESS_TOKEN_KEY=$TWITTER_ACCESS_TOKEN_KEY TWITTER_ACCESS_TOKEN_SECRET=$TWITTER_ACCESS_TOKEN_SECRET --from-code https://github.com/OpenShift-Cookbook/chapter7-recipe4.git

在应用程序成功创建后，每次发布职位都会发送一条推文。

另见

使用 JBoss EAP 和 PostgreSQL 9.2 插件创建和部署 Java EE 6 应用程序食谱
使用管理 Web 界面和 CLI 管理 JBoss 插件食谱

使用管理 Web 界面和 CLI 管理 JBoss 插件

JBoss 提供了三种不同的方式来管理服务器：Web 界面、命令行客户端和 XML 配置文件。在这个食谱中，您将学习如何使用 Web 管理界面和 JBoss CLI 将 WAR 文件部署到您的 JBoss 插件。

准备工作

要完成这个食谱，您需要在本地计算机上拥有 JBoss 应用服务器二进制文件。这是通过jboss-cli连接 JBoss 插件所必需的。您可以从官方网站下载 JBoss AS7 二进制文件，网址是www.jboss.org/jbossas/downloads。解压 ZIP 文件，您将找到jboss-cli脚本文件，它位于bin文件夹中。

在这个食谱中，我们将使用在使用 JBoss EAP 和 PostgreSQL 9.2 插件创建和部署 Java EE 6 应用程序食谱中创建的jobstore应用程序。

如何操作……

执行以下步骤：

打开一个新的命令行终端，并导航到jobstore应用程序所在的目录。运行rhc port-forward命令以将远程端口转发到本地计算机：

$ rhc port-forward --app myapp
To connect to a service running on OpenShift, use the Local address

Service    Local               OpenShift
---------- -------------- ---- ------------------
java       127.0.0.1:3528  =>  127.8.104.129:3528
java       127.0.0.1:4447  =>  127.8.104.129:4447
java       127.0.0.1:5445  =>  127.8.104.129:5445
java       127.0.0.1:8080  =>  127.8.104.129:8080
java       127.0.0.1:9990  =>  127.8.104.129:9990
java       127.0.0.1:9999  =>  127.8.104.129:9999
postgresql 127.0.0.1:5433  =>  127.8.104.130:5432

Press CTRL-C to terminate port forwarding

打开您喜欢的 Web 浏览器，访问http://127.0.0.1:9990的管理界面。此信息可以在rhc port-forward命令的输出中找到。
在这个食谱中，我们将使用 JBoss 管理界面部署我们在使用 JBoss EAP 和 PostgreSQL 9.2 插件创建和部署 Java EE 6 应用程序食谱中创建的应用程序的 WAR 文件。将 WAR 文件从github.com/OpenShift-Cookbook/chapter7-recipe5/raw/master/ROOT.war下载到您的本地计算机。
下载 WAR 文件后，转到运行时 | 管理部署，通过点击删除按钮删除现有的ROOT.war文件，如下截图所示。系统会要求你确认删除操作，你可以点击确定按钮。请查看以下截图：
要部署 WAR 文件，点击添加按钮，然后从本地计算机上传ROOT.war文件。上传 WAR 文件后，系统会要求你验证部署名称。选择默认值，并点击保存按钮，如下截图所示：
上传 WAR 文件并不会启动部署。你必须点击启用/禁用按钮来启动部署。系统会要求你确认决策。点击确认按钮，如下截图所示：
现在，如果你访问http://myapp-{domain-name}.rhcloud.com，你会看到已部署的应用程序。
部署应用程序的另一种方式是通过jboss-cli命令行接口。你可以在本地下载的 JBoss 压缩包的bin文件夹中找到jboss-cli脚本。启动jboss-cli客户端，你会看到如下命令显示的消息：
```
$ ~/ jboss-eap-6.2/bin/jboss-cli.sh 
You are disconnected at the moment. Type 'connect' to connect to the server or 'help' for the list of supported commands.
[disconnected /]
```
要连接到 JBoss 卡带，请输入如下的connect命令：
```
[disconnected /] connect 
[standalone@localhost:9999 /]
```
现在，你可以使用deploy命令检查已部署的应用程序。输入deploy，然后按Enter：
```
[standalone@localhost:9999 /] deploy 

ROOT.war
```
如你在前面的命令中看到的，ROOT.war当前已部署。这个 WAR 文件是通过网页界面部署的。要撤销这个 WAR 文件的部署，输入undeploy命令：
```
[standalone@localhost:9999 /] undeploy ROOT.war
```
现在，如果你访问http://myapp-{domain-name}.rhcloud.com，你会遇到 404 错误，因为应用程序尚未部署。
要使用jboss-cli部署应用程序，你可以使用如下命令行中的deploy命令。请确保你已经按照第 3 步讨论的内容下载了应用程序的ROOT.war文件。请查看以下命令：
```
[standalone@localhost:9999 /] deploy ~/chapter5/recipe8/jobstore/ROOT.war
[standalone@localhost:9999 /]
```
最后，你可以在http://myapp-{domain-name}.rhcloud.com查看正在运行的应用程序。

它是如何工作的…

在前面的步骤中，你学习了如何通过 JBoss 网页管理和命令行界面管理应用程序部署。在第 1 步中，你运行了rhc port-forward命令来启用 SSH 端口转发。rhc port-forward命令将应用程序设备上运行的所有远程端口转发到你的本地计算机。在rhc port-forward命令的输出中，你可以看到管理界面暴露在9090端口。

从第 3 步到第 5 步，你已经了解如何从本地机器连接到 Web 界面并撤销现有的ROOT.war文件。Web 界面是一个Google Web Toolkit（GWT）应用，可以通过端口9090访问。Google Web Toolkit 是一个开源工具集，允许 Java 开发人员用 Java 编写复杂的基于 JavaScript 的 Web 应用程序。OpenShift 只暴露端口8080到外部，所有其他端口仅在应用程序 gear 内部可用，并且只能通过端口转发连接。这是一种安全的设置，因为外部无法连接到你的应用程序 Web 管理界面，因为rhc port-forward命令只有在上传了 SSH 密钥的情况下才有效。Web 控制台分为两个主要标签：配置文件和运行时标签。配置文件标签提供对所有子系统配置的访问权限。你可以在不修改 XML 的情况下编辑配置。例如，你可以访问http://127.0.0.1:9990/console/App.html#datasources来编辑datasource配置。运行时标签可用于管理应用程序部署，你在第 5 步中使用它来撤销 WAR 文件的部署。你可以通过docs.jboss.org/author/display/AS7/Admin+Guide了解更多关于管理界面的文档。

在第 6 步中，你将ROOT.war文件上传到你的 JBoss cartridge。上传后，部署会出现在部署表格中。WAR 文件默认不会自动部署；你需要点击启用/禁用按钮来启用应用程序的部署，正如你在第 7 步中所做的那样。

另一种部署应用的方法是使用jboss-cli命令行界面。在第 9 步中，你启动了jboss-cli脚本。jboss-cli控制台提供了内建的自动完成功能，可以使用Tab键。任何时候，你都可以通过按Tab键列出所有可用的命令，如以下命令所示。为了简洁，下面只显示部分输出：

[standalone@localhost:9999 /] 
alias               connection-factory  help                ls       read-operation      version….

在第 9 步中，你使用undeploy命令撤销了现有的ROOT.war文件。undeploy命令将已部署的应用程序作为参数。最后，在第 10 步中，你使用deploy命令将ROOT.war文件从本地机器部署到运行在 OpenShift 上的 JBoss cartridge。

参见

通过在 standalone.xml 中定义数据库登录模块配置应用程序安全性的配方
使用 JBoss cartridges 安装模块的配方

使用 Tomcat 7 cartridge 创建和部署 Spring 应用

Spring Framework 是一种非常流行的 Java EE Web 开发替代方案。全球的 Java 开发者都使用 Spring Framework 来构建他们的企业应用程序。Spring Framework 通常被认为是 Java EE 的轻量级替代品，Java 开发者通常使用轻量级 Web 容器，如 Apache Tomcat，进行部署。在撰写本文时，OpenShift 支持两个版本的 Apache Tomcat：Apache Tomcat 6 和 Apache Tomcat 7。它们可以通过以下命令显示：

$ rhc cartridges|grep Tomcat
jbossews-1.0        Tomcat 6 (JBoss EWS 1.0)                web
jbossews-2.0        Tomcat 7 (JBoss EWS 2.0)                web

在本教程中，您将学习如何从头开始使用 OpenShift 的 Tomcat 7 插件开发一个简单的 Spring Framework 应用程序。该应用程序公开一个 REST 接口。当用户向 /api/v1/ping 发送 HTTP 请求时，应用程序将返回一个包含消息 It works 的 JSON 响应。

本教程中创建的应用程序源代码托管在 GitHub 上，网址为 github.com/OpenShift-Cookbook/chapter7-jobstore-spring。

准备工作

要完成本教程，您需要在机器上安装 rhc 命令行客户端。请参考第一章中的 安装 OpenShift rhc 命令行客户端 章节，了解详细信息。

如何实现……

执行以下步骤以使用 Spring Framework 创建一个应用程序：

打开一个新的命令行终端，并前往一个方便的位置。通过执行以下命令创建一个新的 Tomcat 7 和 MySQL 5.5 应用程序：
```
$ rhc create-appmyapp tomcat-7
```
上述命令将创建一个基于 Maven 的项目并将其克隆到本地机器。
打开 Eclipse 并导航到项目工作空间。然后，将步骤 1 中创建的应用程序作为 Maven 应用程序导入。要导入现有的 Maven 项目，导航至 File|Import|Maven|Existing Maven Projects。然后浏览到步骤 1 中创建的 OpenShift Maven 应用程序的位置。
接下来，更新 pom.xml 以使用 Java 7。OpenShift 创建的 Maven 项目默认配置为使用 JDK 6。将属性替换为以下代码所示的内容：
```
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
```
更新 Maven 项目以使更改生效。您可以通过右键单击项目并导航至 Maven|Update Project 来更新 Maven 项目。

将 Spring Maven 依赖项添加到 pom.xml 文件中。这些是您使用 Spring Framework 编写 REST JSON Web 服务所需的最低依赖项。代码如下：

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>4.0.3.RELEASE</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.3.1</version>
</dependency>

创建一个名为 org.myapp.config 的新包，并创建一个名为 WebMvcConfig 的新类：

@EnableWebMvc
@ComponentScan(basePackageClasses = PingResource.class)
@Configuration
public class WebMvcConfig extends WebMvcConfigurerAdapter {

    @Bean
    public MappingJackson2JsonView jsonView() {
        MappingJackson2JsonView jsonView = new MappingJackson2JsonView();
        jsonView.setPrefixJson(true);
        return jsonView;
    }
}

在 org.myapp.config 包中创建另一个配置类。此 @Configuration 类将用于定义应用程序 Bean，例如 datasource 等。稍后将在本教程中介绍。代码如下：
```
import org.springframework.context.annotation.Configuration;

@Configuration
public class ApplicationConfig {
}
```

从 Servlet 3.0 开始，web.xml部署描述符变为可选。在 Servlet 3.0 之前，我们在web.xml中配置了 Spring MVC 调度器 Servlet，但现在我们可以通过WebApplicationInitializer进行编程配置。创建一个名为JobStoreWebApplicationInitializer的新类，并将其放置在org.myapp.config包中，具体代码如下：

public class JobStoreWebApplicationInitializer implements WebApplicationInitializer {
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        AnnotationConfigWebApplicationContext webApplicationContext = new AnnotationConfigWebApplicationContext();
        webApplicationContext.register(ApplicationConfig.class, WebMvcConfig.class);

        Dynamic dynamc = servletContext.addServlet("dispatcherServlet", new DispatcherServlet(webApplicationContext));
        dynamc.addMapping("/api/v1/*");
        dynamc.setLoadOnStartup(1);
    }

}

现在，我们将创建一个名为PingResource的简单 REST 资源。当请求访问/api/v1/ping时，PingResource将被调用并以 JSON 消息做出响应。创建一个新的类PingResource，并将其放置在org.myapp.rest包中。查看以下代码：
```
@Controller
@RequestMapping("/ping")
public class PingResource {

@RequestMapping(method=RequestMethod.GET,produces=MediaType.APPLICATION_JSON_VALUE)
public @ResponseBody PingResponse ping(){
return new PingResponse("It works!!");
}
}
```

同时，创建另一个名为PingResponse的类，如下所示的代码所示：

public class PingResponse {

private String message;

public PingResponse(String message) {
this.message = message;
}

public String getMessage() {
return message;
}
}

提交更改并将其推送到 OpenShift 应用程序设备，具体步骤如下：
```
$ git add .
$ git commit -am "Spring 4 application"
$ git push
```
你可以使用命令行工具（如curl）或在浏览器中打开http://myapp-{domain-name}.rhcloud.com/api/v1/ping来测试PingResource。你应该会看到以下 JSON 消息：
```
$ curl http://myapp-osbook.rhcloud.com/api/v1/ping

{"message":"It works!!"}
```

它是如何工作的……

在前面的步骤中，我们创建了一个 Spring 应用并将其部署到 OpenShift。在第 1 步中，你使用rhc create-app命令创建了 Apache Tomcat 7 和 MySQL 5.5 的应用。每个 OpenShift Web Cartridge 都指定了一个模板应用，它将作为应用的默认源代码。对于基于 Java 的 Web Cartridge（如 JBoss EAP、JBoss AS7、Tomcat 6 和 Tomcat 7），模板是基于 Maven 的应用程序。创建应用后，模板应用会通过 Git 克隆到本地机器。应用的目录结构如下所示：

$ ls -a
.git .openshift README.md pom.xml webapps src

如前面命令行输出所示，除了.git和.openshift目录外，这看起来像一个标准的 Maven 项目。OpenShift 使用 Maven 来管理应用程序依赖关系并构建 Java 应用程序。

目录结构在使用 JBoss EAP 和 PostgreSQL 9.2 Cartridge 创建和部署 Java EE 6 应用程序一文中进行了说明。请参阅该文档以了解目录结构。

从第 3 步到第 5 步，你对pom.xml做了一些修改。你更新了项目，使其使用 JDK 1.7 作为 Maven 编译插件的 JDK 版本。所有的 OpenShift Java 应用都使用 OpenJDK 7，因此将应用程序更新为使用 JDK 1.7 进行编译是合适的。你对pom.xml的另一个修改是更新了 Maven WAR 插件配置，以便在找不到web.xml时不会导致构建失败。接下来，你向pom.xml中添加了 Spring Web MVC 依赖。Servlet 3.1.0 已提供，因为它应该存在于 Apache Tomcat 7 中。jackson-databind依赖被添加进来，用于将 Java 对象转换为 JSON。

从第 6 步到第 8 步，您以编程方式配置了 Spring Web MVC 框架。通常情况下，我们在web.xml中配置 Spring Web MVC 调度程序 Servlet，但现在我们可以使用WebApplicationInitializer进行程序化配置。从 Spring 3.1 开始，Spring 提供了一个ServletContainerInitializer接口的实现称为SpringServletContainerInitializer。SpringServletContainerInitializer类委托给您提供的org.springframework.web.WebApplicationInitializer的实现。您只需要实现一个方法：WebApplicationInitializer#onStartup(ServletContext)。您将获得需要初始化的ServletContext参数。

从第 9 步到第 11 步，您使用 Spring MVC 创建了一个简单的 REST JSON 资源PingResource。使用@RequestMapping注解将PingResource定义为/api/v1/pingURL 可用。

还有更多…

您可以仅使用以下单个命令执行所有前述步骤：

$ rhc create-app jobstore tomcat-7 mysql-5.5 --from-code https://github.com/OpenShift-Cookbook/chapter7-spring-recipe.git --timeout 180

参见

获取 Java 载体的线程转储食谱

获取 Java 载体的线程转储

在此食谱中，您将学习如何获取 Java 载体应用程序的线程转储。线程转储列出了当前在Java 虚拟机（JVM）中活动的所有 Java 线程。它可以帮助您了解 JVM 中每个线程在特定时间点的状态。它为您提供了在某个时间点正在执行的确切快照。线程转储对于调试死锁条件或了解资源使用非常有用。

注意

该命令适用于所有四种支持的 Java 载体（Apache Tomcat 6、Apache Tomcat 7、JBoss AS7 和 JBoss EAP）。

准备工作

该食谱将请求创建和部署 Java EE 6 应用程序使用 JBoss EAP 和 PostgreSQL 9.2 载体中的应用程序的线程转储。因此，请在继续本食谱之前参考上述食谱。

如何操作…

执行以下步骤获取 Java 应用程序的线程转储：

打开一个新的命令行终端，并导航到jobstore应用程序所在的目录。
要获取jobstore应用程序的线程转储，请运行以下命令：
```
$ rhc threaddump --app jobstore
```

工作原理…

运行rhc threaddump命令时，JBoss EAP 载体会初始化一个线程转储。首先获取 JBoss 应用服务器的进程 ID，然后运行kill -3 <process id>命令。kill -3命令向 Java 进程发送HUP或BREAK信号。线程转储日志将放置在$OPENSHIFT_LOG_DIR/中的jbosseap.log文件中，您可以下载到本地机器进行分析。您还可以使用rhc tail命令查看日志文件，如下命令输出中所述：

$ rhc tail -f app-root/logs/jbosseap.log -o '-n 250'

要在本地机器上下载线程转储文件，你可以使用rhc scp命令。rhc scp命令可以用来通过 SCP（en.wikipedia.org/wiki/Secure_copy）传输文件到应用程序和从应用程序传输文件。运行以下命令以下载jbosseap.log文件：

$ rhc scp jobstore download ./ app-root/logs/jbosseap.log

现在，你可以使用工具，如 samurai（yusuke.homeip.net/samurai/en/index.html），在本地机器上分析线程转储。

还有更多内容…

你还可以使用jps和jstack JVM 工具获取 Java 应用程序的线程转储。要执行此操作，请按照以下步骤进行：

打开命令行终端，然后使用 SSH 连接到jobstore应用程序 gear，如下所示：
```
$ rhc ssh --app jobstore
```
进入应用程序 gear 后，运行jps工具列出所有可用的 Java 进程，如下所示：
```
$ jps –l
```
jps工具随 JDK 一起提供，用于列出所有 Java 进程 ID。

jps -l命令的输出如下：

59850 sun.tools.jps.Jps
157027 /var/lib/openshift/541ecec35004466ec000007f/jbosseap/jboss-modules.jar

现在，要获取 ID 为157027的 Java 进程的线程转储，运行以下命令：
```
$ jstack 157027 >> /tmp/threaddump.log
```
jstack工具也是 JDK 的一部分，用于获取 Java 进程的线程转储。

参见

在 Java 6 和 Java 7 之间的选择配方
为 Java 应用程序启用热部署配方
使用 JBoss EAP 和 PostgreSQL 9.2 cartridge 创建和部署 Java EE 6 应用程序配方

在 Java 6 和 Java 7 之间的选择

OpenShift 支持 Java 6 和 Java 7 来运行你的应用程序。默认情况下，所有 Java 应用程序使用 OpenJDK 7，但你也可以配置应用程序使用 OpenJDK 6。要获取 Java 安装的确切版本，你可以通过 SSH 连接到应用程序 gear 并运行java -version命令，或运行以下命令：

$ rhc ssh --app jobstore --command "java -version"

在本配方中，你将学习如何在不同的支持的 Java 版本中进行选择。

注意

这个配方适用于所有四种支持的 Java cartridge（Apache Tomcat 6，Apache Tomcat 7，JBoss AS7 和 JBoss EAP）。

如何操作…

执行以下步骤以切换到 OpenJDK 6：

通过运行以下命令创建一个新的 JBoss AS 7 应用程序。如果你已经在 OpenShift 上部署了 Java 应用程序，则可以使用该应用程序。
```
$ rhc create-app myapp jbossas-7
```

一旦应用程序创建完成，你可以通过在应用程序 gear 上运行java -version命令来检查默认的 Java 版本，如以下命令所示：

$ rhc ssh --command "java -version"
java version "1.7.0_51"
OpenJDK Runtime Environment (rhel-2.4.4.1.el6_5-i386 u51-b02)
OpenJDK Server VM (build 24.45-b08, mixed mode)

要配置应用程序使用 Java 6，删除位于.openshift/markers目录中的名为java7的标记文件，如下所示：
```
$ rm –f .openshift/markers/java7
```
提交更改并将其推送到应用程序 gear，如下所示：
```
$ git commit –am "switched to Java 6"
$ git push
```

在成功构建后，再次运行java -version命令以验证你现在使用的是 Java 6，如下所示：

$ rhc ssh --command "java -version"
java version "1.6.0_30"
OpenJDK Runtime Environment (IcedTea6 1.13.1) (rhel-3.1.13.1.el6_5-i386)
OpenJDK Server VM (build 23.25-b01, mixed mode)

它是如何工作的…

OpenShift 使用标记文件来配置应用程序的各种方面，例如 Java 版本、热部署、调试等。在.openshift/markers位置存在标记文件告诉 OpenShift 你想要启用的功能。例如，每个 OpenShift 应用程序在.openshift/markers目录中都有一个java7标记文件，告诉 OpenShift 在应用程序部署时使用 Java 7。当你使用git push进行代码部署时，OpenShift 会根据你在应用程序中想要使用的 Java 版本设置JAVA_HOME环境变量。

要使用 Java 6，你只需删除java7标记文件。这会通知 OpenShift 应该回退到 Java 6。从现在开始，你的应用程序将使用 Java 6。

参见

获取 Java cartridges 线程转储的步骤
为 Java 应用程序启用热部署的步骤

为 Java 应用程序启用热部署

每次进行更改并将其推送到 OpenShift 应用程序齿轮时，OpenShift 会停止你的齿轮（即所有的 cartridges），从你的应用程序 Git 仓库复制源代码到app-root/runtime/repo，执行构建，准备构件，最后启动你的齿轮（即所有的 cartridges）。这个过程需要时间，不适合快速开发。为了实现快速开发和更快的部署，OpenShift 支持热部署。热部署意味着你可以在不需要重新启动所有应用程序 cartridges 的情况下部署你的更改。

注意

此步骤适用于所有四种支持的 Java cartridges（Apache Tomcat 6、Apache Tomcat 7、JBoss AS7 和 JBoss EAP）。

如何操作…

执行以下步骤以启用热部署：

打开一个新的命令行终端，并导航到你想创建应用程序的目录。要创建一个新的 JBoss EAP 应用程序，请执行以下命令。如果你已经有一个 OpenShift Java 应用程序，那么你也可以使用它。看看以下命令：
```
$ rhc create-app myapp jbosseap
```
要启用热部署，请在.openshift/markers目录下创建一个名为hot_deploy的新文件。在*nix 机器上，你可以使用touch命令创建一个新文件，如下所示的命令。在 Windows 机器上，你可以使用文件浏览器创建一个新文件。看看以下代码：
```
$ touch .openshift/markers/hot_deploy
```
将新文件添加到 Git 仓库索引中，提交到本地仓库，然后将更改推送到应用程序的远程 Git 仓库：
```
$ git add .openshift/markers/hot_deploy
$ git commit –am "enabled hot deployment"
$ git push
```
在git push日志中，你会看到一个消息，说明 cartridges 没有停止，因为已启用热部署，如下所示：
```
remote: Not stopping cartridge jbosseap because hot deploy is enabled
```

工作原理…

hot_deploy 标记文件的存在会通知 OpenShift 你希望进行热部署。在停止和启动应用程序卡带之前，OpenShift 会检查 hot_deploy 标记文件是否存在。对于 JBoss 卡带，热部署是通过使用 JBoss 部署扫描器来实现的。扫描器每 5 秒钟检查一次 deployments 目录，查看是否存在 WAR 文件。如果 WAR 文件存在，它会卸载现有的 WAR 文件并部署新的 WAR 文件。你可以在 .openshift/config/standalone.xml 中配置部署扫描器的 scan-interval 选项：

<subsystem >
<deployment-scanner path="deployments" relative-to="jboss.server.base.dir"
scan-interval="5000" deployment-timeout="300" />
</subsystem>

当你的应用使用热部署时，应用程序将会有一段停机时间，停机开始于 JBoss 部署扫描器识别到新的 WAR 文件，卸载旧的文件并部署新的文件。应用程序将在新的文件部署完成后恢复上线。

热部署非常适合开发，我建议在开发过程中始终使用它。

注意

如果你在启用热部署的情况下设置了新的环境变量，那么你必须重新启动应用程序，以便服务器能够识别新的环境变量。

另见

获取 Java 卡带的线程转储 这个教程
在 Java 6 和 Java 7 之间选择 这个教程

跳过 Maven 构建

每个 OpenShift Java 应用都是基于 Maven 的应用。每当你运行 git push 命令时，都会执行一个 Maven 构建，生成的归档文件（WAR 或 EAR）会被部署。有些场景下，你可能不希望在每次推送到 Gear 时都执行 Maven 构建。这些场景包括 WAR 部署或仅执行动作钩子。在本教程中，你将学习如何在部署过程中跳过 Maven 构建步骤。

注意

本教程适用于所有四个支持的 Java 卡带（Apache Tomcat 6、Apache Tomcat 7、JBoss AS7 和 JBoss EAP）。

准备工作

要完成本教程，你需要在 使用 JBoss EAP 和 PostgreSQL 9.2 卡带创建并部署 Java EE 6 应用程序 中创建的 jobstore 应用。如果你没有正在运行的 OpenShift 应用，请参考该教程。

如何操作…

执行以下步骤以跳过 Maven 构建：

打开一个新的命令行终端，导航到 jobstore 应用所在的目录。如果你没有 Java OpenShift 应用，可以按照 使用 JBoss EAP 和 PostgreSQL 9.2 卡带创建并部署 Java EE 6 应用程序 中的步骤重新创建一个新应用。
要在部署过程中跳过 Maven 构建，请在 .openshift/markers 目录下创建一个名为 skip_maven_build 的标记文件。在 *nix 系统上，你可以使用如下命令中的 touch 命令。在 Windows 系统上，你可以使用文件资源管理器。请参考以下代码：
```
$ touch .openshift/markers/skip_maven_build
```
将新文件添加到 Git 仓库索引，提交到本地仓库，然后将更改推送到应用程序的远程 Git 仓库，如下所示：
```
$ git add .openshift/markers/skip_maven_build
$ git commit –am "skipmaven build"
$ git push
```

它是如何工作的……

skip_maven_build 标记的存在通知 OpenShift 不需要构建应用程序。在 git push 命令的输出中，你会看到由于存在 skip_maven_build 标记文件，Maven 构建被跳过：

remote: skip_maven_build marker found; build will be skipped

还有更多……

另一种跳过 Maven 构建的方法是删除 pom.xml 文件。如果没有 pom.xml 文件，OpenShift 就不会尝试构建应用程序。

另见

强制进行干净的 Maven 构建 配方
安装不在 Maven 中央仓库中的 JAR 文件 配方
覆盖默认 Maven 构建命令 配方

强制进行干净的 Maven 构建

第一次将更改推送到应用程序 gear 时，Maven 会下载所有依赖项并将这些依赖项存储在应用程序 gear 主目录下的 .m2 目录中。第一次推送后，OpenShift 将重用 .m2 仓库中的所有依赖项，只会下载新的依赖项。这可以节省构建时间并加快应用程序部署。但也有一些情况你需要进行干净的构建。一种情况是你希望下载所有最新的 Maven 依赖项。在此配方中，你将学习如何通知 OpenShift 执行干净的构建。

注意

此配方适用于所有四个支持的 Java 套件（Apache Tomcat 6、Apache Tomcat 7、JBoss AS7 和 JBoss EAP）。

准备工作

要完成此配方，你需要在 使用 JBoss EAP 和 PostgreSQL 9.2 套件创建并部署 Java EE 6 应用程序 配方中创建的 jobstore 应用程序。如果你没有正在运行的 OpenShift 应用程序，请参考此配方。

如何操作……

执行以下步骤以强制进行 Java 应用程序的干净 Maven 构建：

打开一个新的命令行终端，导航到 jobstore 应用程序所在的目录。如果你没有 Java OpenShift 应用程序，可以按照 使用 JBoss EAP 和 PostgreSQL 9.2 套件创建并部署 Java EE 6 应用程序 配方中的步骤重新创建一个新的应用程序。
在部署期间强制进行干净的 Maven 构建，请在应用程序的 .openshift/markers 目录中创建一个名为 force_clean_build 的标记文件。在 *nix 系统上，可以使用以下命令中的 touch 命令。对于 Windows 系统，可以使用文件资源管理器。请查看以下截图：
```
$ touch .openshift/markers/force_clean_build
```
将新文件添加到 Git 仓库索引，提交到本地仓库，然后将更改推送到应用程序的远程 Git 仓库，如下所示：
```
$ git add .openshift/markers/force_clean_build
$ git commit –am "force_clean_buildmarker added"
$ git push
```

它是如何工作的……

force_clean_build标记文件的存在告诉 OpenShift 你想进行一个干净的构建。当你运行git push命令时，OpenShift 将首先删除.m2目录，然后通过调用mvn clean package -Popenshift -DskipTests命令来启动构建过程。Maven 现在会重新下载所有的依赖项。你会在git push命令输出中看到以下日志信息。请查看以下命令：

remote: Force clean build enabled - cleaning dependencies

另见

强制进行干净的 Maven 构建配方
安装不在 Maven 中央仓库中的 JAR 文件配方
覆盖默认的 Maven 构建命令配方

覆盖默认的 Maven 构建命令

默认情况下，OpenShift 将执行mvn -e clean package -Popenshift -DskipTests命令来构建项目。如果你不想使用 OpenShift Maven 配置文件，或者希望运行测试，那么你必须告诉 OpenShift 运行一个不同的命令。在本配方中，你将学习如何告诉 OpenShift 使用不同的命令。

准备工作

要完成本配方，你需要使用创建和部署 Java EE 6 应用程序，使用 JBoss EAP 和 PostgreSQL 9.2 cartridge配方中创建的jobstore应用程序。如果你没有正在运行的 OpenShift 应用程序，请参考该配方。

如何执行…

执行以下步骤来覆盖默认的 Maven 构建命令：

打开一个新的命令行终端，并导航到jobstore应用程序所在的目录。
要配置 OpenShift 使用不同的构建命令，请创建一个名为MAVEN_ARGS的新环境变量。MAVEN_ARGS环境变量的值是你希望运行的 Maven 构建阶段，如以下命令所示：
```
$ rhc env-set MAVEN_ARGS="clean install"
```

它是如何工作的…

在运行构建之前，OpenShift 首先检查名为MAVEN_ARGS的环境变量是否已设置。它使用该环境变量中定义的阶段和目标来创建一个 Maven 命令，用于构建项目。如果MAVEN_ARGS未设置，则会设置默认值，即clean package -Popenshift -DskipTests，否则将使用MAVEN_ARGS环境变量的值。

现在，当你运行git push命令时，你将在git push日志中看到一条记录，如以下命令输出所示：

remote: Found pom.xml... attempting to build with 'mvn -e clean install'

另见

强制进行干净的 Maven 构建配方
安装不在 Maven 中央仓库中的 JAR 文件配方
跳过 Maven 构建配方

安装不在 Maven 中央仓库中的 JAR 文件

OpenShift 将从你pom.xml文件中指定的 Maven 中央仓库下载所有的依赖项。有时候，你的应用程序依赖于在任何公共 Maven 仓库中都不存在的库。在本配方中，你将学习如何使用 OpenShift 的操作钩子来安装本地 JAR 文件。

准备工作

要完成此方案，你需要在使用 JBoss EAP 和 PostgreSQL 9.2 插件创建和部署 Java EE 6 应用程序 方案中创建的jobstore应用程序。如果你没有正在运行的 OpenShift 应用程序，请参考此方案。

如何操作……

执行以下步骤以安装未出现在配置的 Maven 仓库中的 JAR 文件：

打开一个新的命令行终端，并导航到jobstore应用程序所在的目录。
在应用程序目录的根目录中创建一个lib目录，并将本地 JAR 文件添加到这里。为了演示这个方案，我创建了一个简单的库，你可以从github.com/OpenShift-Cookbook/chapter7-recipe14/raw/master/lib/simplelogger-0.0.1.jar下载。
在.openshift/action_hooks目录中创建一个pre_build操作钩子，并将以下内容添加到其中：
```
#!/bin/bash
```
以下命令将把 JAR 文件安装到位于应用程序 gear 上的本地 Maven 仓库：
```
mvn install:install-file -Dfile=$OPENSHIFT_REPO_DIR/lib/simplelogger-0.0.1.jar -DgroupId=org.osbook -DartifactId=simplelogger -Dversion=0.0.1 -Dpackaging=jar
```
确保pre_build操作钩子是可执行的。你可以通过运行以下命令来使pre_build操作钩子脚本可执行：
```
$ chmod +x .openshift/action_hooks/pre_build
```
将依赖项添加到应用程序的pom.xml文件中，以便你的应用程序可以在应用程序源代码中使用该库，如下所示：
```
<dependency>
<groupId>org.osbook</groupId>
<artifactId>simplelogger</artifactId>
<version>0.0.1</version>
</dependency>
```

它是如何工作的……

在步骤 2 中，你在应用程序源代码的根目录内创建了一个lib目录。你下载了simplelogging库并将其放置在lib目录中。接下来，在步骤 2 中，你创建了一个pre_build操作钩子，它将simplelogging-0.0.1.jar文件安装到应用程序 gear 的.m2仓库中。pre_build脚本在构建步骤之前执行。这意味着你的库在构建过程中将可用。

注意

在 Windows 上，操作钩子的执行权限会在git push过程中丢失。你可以通过运行以下命令来解决这个问题：

git update-index --chmod=+x .openshift/action_hooks/*

最后，你将库作为依赖项添加到应用程序的pom.xml文件中，这样就可以在应用程序中使用该库。

另请参阅

强制进行清理的 Maven 构建 方案
覆盖默认 Maven 构建命令 方案
跳过 Maven 构建 方案

使用 Eclipse 开发 OpenShift Java 应用程序

你可以直接在 Eclipse IDE 内使用 JBoss Tools OpenShift 插件来构建、部署和管理 OpenShift Java 应用程序。这个方案将引导你完成安装、设置、应用程序创建以及在 Eclipse 中管理应用程序的过程。在这个方案中，你将开发一个 Java EE 6 PostgreSQL 9.2 应用程序，并将其部署在运行 OpenShift 的 JBoss EAP 6 应用服务器上，所有操作都在 Eclipse 内完成。

准备工作

从官方 Eclipse 网站下载适合您操作系统的最新 Eclipse 包，网址为www.eclipse.org/downloads/。在撰写本文时，最新的 Eclipse 包是 Kepler 版本。

安装 Eclipse 非常简单，只需解压下载的包即可完成。在 Linux 和 Mac 系统上，打开一个新的命令行终端，并输入以下命令：

$ tar -xzvf eclipse-jee-kepler-R-*.tar.gz

在 Windows 系统上，您可以使用 WinZip 或 7-zip（www.7-zip.org/download.html）或任何其他软件来解压 ZIP 文件。

提取 Eclipse 文件后，在我们提取 Eclipse 的目录中会有一个名为*eclipse*的文件夹。我们可以选择性地创建一个快捷方式指向可执行文件。

注意

建议您使用最新版本的 Eclipse，即 Kepler，来与 OpenShift 配合使用。早期版本不再支持，甚至可能无法正常工作。

操作步骤…

执行以下步骤，使用 OpenShift Eclipse 工具创建 OpenShift 应用程序：

下载并解压 Eclipse Kepler IDE for Java EE 后，打开 Eclipse，进入项目工作区。导航到帮助|Eclipse 市场。
在搜索框中输入jboss tools，然后点击前往按钮。点击前往按钮后，我们会看到JBoss Tools (Kepler)作为第一个结果。现在点击安装按钮。请查看以下截图：
点击安装按钮后，您将看到可以安装的插件列表。由于本食谱的目的是演示 OpenShift Eclipse 的支持，我们只会从列表中选择JBoss OpenShift Tools。选择JBoss OpenShift Tools后，点击确认按钮。请查看以下截图：
通过点击我接受许可协议的条款单选按钮来接受许可协议，然后点击完成按钮。
由于 JBoss Tools OpenShift 插件没有签名，您会收到安全提示。点击确定按钮，重新启动 Eclipse 以应用更改。
现在您已经安装了 OpenShift Eclipse 插件，您拥有了构建应用程序所需的一切。通过导航到文件|新建|其他|OpenShift 应用程序来创建一个新的 OpenShift 应用程序：
点击下一步按钮，您将被要求提供您的 OpenShift 账户凭证。如果您没有 OpenShift 账户，可以点击向导中的在这里注册链接创建一个新的 OpenShift 账户。请查看以下截图：
输入您的 OpenShift 账户信息。同时，勾选保存密码复选框，这样我们就不需要在每次命令时都输入密码。点击下一步按钮。请查看以下截图：
点击下一步按钮后，系统将要求您输入密码恢复的附加信息。我选择否，但您也可以选择是。
接下来，如果您的账户尚未关联域名，系统将要求您创建一个新的 OpenShift 域名。域名是唯一的命名空间，所有用户应用程序都将在该命名空间下存在。以下截图展示了此内容：
接下来，系统会要求您将公钥 SSH 上传至 OpenShift，如下所示截图所示：
您可以上传现有的 SSH 密钥，也可以通过点击新建按钮创建一个新的 SSH 密钥。我们通过点击新建按钮来创建一个新的密钥。我们需要为密钥提供一个名称，以及为私钥和公钥文件指定文件名。我使用了我的名字作为密钥名称和文件名。请查看以下截图：
现在，您将进入应用程序创建向导，在此您需要输入应用程序的详细信息。这些详细信息包括应用程序的名称、应用程序类型、实例配置（您希望使用小型、中型还是大型实例；在免费层中，您仅能使用小型实例）、是否希望应用程序可扩展，是否希望嵌入任何或多个插件，例如 MySQL、PostgreSQL、MongoDB 等。对于我们的应用程序，我们将选择 JBoss EAP 和 PostgreSQL 插件。我们将把应用程序命名为 jobstore，如下所示的截图所示：
接下来，您需要设置一个jobstore应用程序并配置服务器适配器设置。选择默认设置并点击下一步。
下一屏幕会要求我们指定克隆 Git 仓库的位置和 Git 远程的名称。请查看以下截图：
最后，点击完成按钮以启动应用程序创建过程。这将为我们创建一个名为 gear 的应用程序容器，并设置所有必要的 SELinux 策略和 cgroup 配置。OpenShift 会在应用程序 gear 上安装 PostgreSQL 插件，并且 JBoss Tools OpenShift 插件将显示一个包含 PostgreSQL 详细信息的消息框。
最后，项目以 Maven 项目的形式导入到 Eclipse 工作区。导入应用程序到 Eclipse 后，系统会询问你是否要发布未提交的更改。你可能会开始怀疑为什么它会要求你发布更改。原因是，当一个项目导入到 Eclipse 时，JBoss Tools 会在.settings目录下创建一个新的文件.jsdtscope。由于该文件没有被忽略，OpenShift Eclipse 插件会要求你进行部署。你可以轻松忽略该文件，通过导航到Git Staging视图来完成。要打开Git Staging视图，导航到窗口|显示视图|其他|Git|Git Staging。请看下面的截图：
在Git Staging视图下，右键点击.jsdtscope文件，然后选择忽略。请看下面的截图：
接下来，打开OpenShift Explorer视图。导航至窗口|显示视图|其他|JBoss 工具|OpenShift Explorer。这将打开一个新视图，如下图所示：
现在，右键点击应用程序，然后点击在 Web 浏览器中显示选项。这将会在默认浏览器中打开模板应用程序。

如何操作…

上述步骤帮助你通过 Eclipse 创建 OpenShift Java 应用程序。在此示例中，我使用了 JBoss EAP cartridge，但你也可以使用 Tomcat 或 JBoss AS7 cartridge 做同样的操作。前面的步骤不需要进一步解释，下面我将向你说明如何进行开发工作流。与 OpenShift Eclipse 工具的推荐工作方式分为两个步骤，具体如下：

编写功能代码，然后通过Git Staging视图将代码提交到 Git 本地仓库。Git Staging视图提供了图形化界面来查看更改，您可以轻松地比较并查看我们所修改的所有文件。
在Git Staging视图中，你有两个选项。你可以选择将更改提交到本地仓库，或者同时执行提交和推送。当你同时执行git commit和push时，代码会推送到名为origin的 Git 远程仓库。origin远程指向 OpenShift 创建的私人 Git 仓库。当代码推送到远程仓库时，OpenShift 会启动构建。Git Staging视图中的提交并推送按钮的问题是，你将无法监控应用程序的构建日志。为了查看应用程序的构建日志，应该使用服务器视图的发布机制。我们将使用为jobstore OpenShift 应用程序配置的服务器。要发布更改，右键点击服务器，然后点击发布。这将执行git push。这种方式的优点是，它会打开一个新的控制台视图，我们可以在其中监控应用程序的构建进度。

让我们对应用程序做一个小的更改，以便更好地理解前一部分中讨论的开发工作流。打开index.html文件，并考虑以下代码：

<h1>
    Welcome to OpenShift, JBossEAP6.0 Cartridge
</h1>

然后将其更改为：

<h1>
Welcome to JobStore application
</h1>

转到Git Staging视图，你将看到以下截图所示的更改：

接下来，将更改拖动到Staged Changes，并写入提交信息。请查看以下截图：

通过点击Commit按钮提交更改。如前所述，切勿使用Commit and Push，因为那样会触发应用程序部署，并且不会显示构建日志。构建日志在构建失败时非常有用。

转到Servers视图，你将看到为jobstore应用程序配置的服务器。

右键点击应用程序服务器，然后点击Publish。请查看以下截图：

你将得到一个对话框，需要确认是否发布更改。点击Yes，这将打开一个新的Console视图，我们可以在其中跟踪构建进度。请查看以下截图：

要查看 JBoss EAP 应用程序服务器的日志文件，请转到OpenShift Explorer视图，右键点击应用程序。点击Tail files…。请查看以下截图：

接下来，你将配置仅跟踪 JBoss EAP 的server.log文件。默认情况下，它将跟踪所有日志文件，包括数据库日志文件，如下图所示：

这将打开另一个控制台视图，届时它将仅跟踪 JBoss EAP 的server.log文件。

最后，我们可以通过右键点击jobstore服务器，然后导航到Show In|Web Browser来在浏览器中查看更改。这将打开默认的 Web 浏览器，我们可以查看在index.html中所做的更改。

还有更多…

你可以使用 OpenShift Eclipse 插件做更多的事情。为了加快开发速度，你应该启用热部署。OpenShift Eclipse 插件使启用热部署变得非常简单。要启用热部署，右键点击项目，然后导航到OpenShift|Configure Markers。请查看以下截图：

然后，你将看到一个视图，在其中可以配置你希望为应用程序启用的 OpenShift 标记。选择Hot Deploy标记。请查看以下截图：

这将创建一个名为hot_deploy的新空文件，位于.openshift/markers目录中。你可以通过进入Git Staging视图提交更改。进入Servers视图，发布此更改。构建日志将显示热部署已启用，因此卡片没有停止。请查看以下构建日志：

Not stopping cartridge jbosseap because hot deploy is enabled
Not stopping cartridge postgresql because hot deploy is enabled

另见

使用 Eclipse 系统资源管理器 SSH 进入应用程序设备 教程
在云中调试 Java 应用程序 教程

使用 Eclipse 系统资源管理器 SSH 进入应用程序设备

在本教程中，您将学习如何通过 Eclipse SSH 进入应用程序设备。

准备工作

本教程要求您安装带有 JBoss Tools OpenShift 插件的 Eclipse。更多信息，请参考 使用 Eclipse 开发 OpenShift Java 应用程序 教程。

如何操作……

执行以下步骤，了解如何通过 Eclipse SSH 进入应用程序设备：

使用 OpenShift Eclipse 插件创建一个新应用程序。有关说明，请参考 使用 Eclipse 开发 OpenShift Java 应用程序 教程。
导航至 Window|Open Perspective|Other|Remote System Explorer 打开 Remote System Explorer 视图。请查看以下截图：
转到 OpenShift Explorer 并复制 SSH 连接详细信息，如下图所示：
复制 SSH 详细信息，如下图所示：
返回到 Remote System Explorer 视图，并定义一个新的远程系统连接，如下图所示：
接下来，系统会要求您选择远程系统类型。选择 仅 SSH 选项，如下图所示：
接下来，您将被要求输入新连接的详细信息。请输入您的应用程序主机名，如下图所示：
点击 Finish 按钮以创建新连接。连接将列在左侧栏中。
要打开 SSH 终端，请按照以下步骤导航到 Ssh Terminals|Launch Terminal：
接下来，系统会要求您输入要连接的用户 ID。用户 ID 是 SSH 连接 URL 中的 UUID 部分。点击 OK。请查看以下截图：
再次启动终端，您将看到如下所示的 SSH 终端：

它的工作原理是……

在前面的步骤中，您使用了 Eclipse 的 Remote System Explorer 来 SSH 进入 OpenShift 应用程序设备。Remote System Explorer 已随 Eclipse Kepler for Java EE 打包。Remote System Explorer 允许您连接并与各种远程系统进行交互。要了解有关 Remote System Explorer 的更多信息，您可以参考文档：help.eclipse.org/kepler/index.jsp?nav=%2F56。

另见

使用 Eclipse 开发 OpenShift Java 应用程序 教程
在云中调试 Java 应用程序 教程

在云中调试 Java 应用程序

在本食谱中，你将学习如何调试运行在 OpenShift 上的 Java 应用程序。

准备就绪

此食谱要求你安装带有 JBoss Tools OpenShift 插件的 Eclipse。有关更多信息，请参考使用 Eclipse 开发 OpenShift Java 应用程序食谱。

操作步骤…

执行以下步骤，学习如何调试 Java 应用程序：

在使用 Eclipse 开发 OpenShift Java 应用程序的食谱中，你学习了如何使用 Eclipse 插件创建 Java 应用程序。我们开发的应用程序使用了 OpenShift 模板应用程序作为起点。如你所知，在rhc命令行中，你可以使用--from-code选项来指定自己的模板应用程序。现在，让我们创建一个新的 Java 应用程序，使用 Eclipse，并使用在使用 JBoss EAP 和 PostgreSQL 9.2 组件创建和部署 Java EE 6 应用程序食谱中创建的应用程序。通过导航到文件|新建|其他|OpenShift 应用程序来创建新的 OpenShift 应用程序。验证你的账户后，会出现一个屏幕，要求你输入应用程序的详细信息。请选择JBoss EAP和PostgreSQL 9.2组件。为了指定 Git 仓库，点击高级按钮，然后取消勾选使用默认源代码复选框。

在输入框中，指定 Git 仓库的 URL，如下图所示：
接下来，你需要设置一个jobstore应用程序并配置服务器适配器设置。选择默认设置，然后点击下一步。
下一屏幕将要求你指定克隆 Git 仓库的位置以及 Git 远程的名称。指定一个可写目录，然后点击完成。
现在，将使用所选的组件和 Git 仓库创建一个新的应用程序实例。最后，项目将作为 Maven 项目导入到 Eclipse 中。
为了启用调试，你必须在.openshift/markers目录中创建一个名为enable_jpda的新标记文件。Eclipse 插件可以帮助我们创建这个文件。右键点击项目，导航到OpenShift | 配置标记…。
这将打开一个对话框，你可以在其中选择标记文件。选择启用 JPDA标记，如下图所示。这将在.openshift/markers目录下创建一个名为enable_jpda的新文件。
进入Git Staging视图，并提交更改。请查看以下截图：
提交更改后，进入服务器视图，发布你的更改。这将启动带有 JPDA 启用的服务器。
现在，启用端口转发，以便你可以连接到 JPDA 端口。进入OpenShift Explorer视图，右键点击项目以启用端口转发。请查看以下截图：
这将打开一个对话框，你可以在其中配置端口转发。点击全部启动按钮以启用端口转发。端口8787用于调试。如以下截图所示：
现在，我们将在CompanyResource类的第 32 行添加断点。设置完调试点后，通过右键单击调试点，依次选择调试配置|远程 Java 应用程序|新建并为其命名，输入端口8787，如下图所示：
输入所有信息后，点击调试按钮。打开调试视角，你将看到远程调试器正在运行。请注意，启用远程调试需要一些时间，请耐心等待。如下图所示：
现在，访问http://jobstore-{domain-name}.rhcloud.com/#companies/new并创建一个新公司。这将触发下图所示的断点：

它是如何工作的……

上述步骤使 Java 开发人员能够调试其 OpenShift Java 应用程序。为了启用调试，你在.openshift/markers目录下使用 Eclipse 插件创建了一个标记文件。该文件已提交，并将更改推送到 OpenShift 应用程序 gear。在推送后，JBoss 服务器会停止并重新启动。JBoss cartridge 会检查是否存在enable_jpda文件。如果enable_jpda标记文件存在，则服务器会以调试模式启动。JBoss 提供的调试基于Java 平台调试架构(JPDA)。为了启用调试，JBoss 服务器会使用以下代码中显示的值设置JAVA_OPTS环境变量来启动：

JAVA_OPTS="-Xdebug -Xrunjdwp:transport=dt_socket,address=${OPENSHIFT_JBOSSEAP_IP}:8787,server=y,suspend=n ${JAVA_OPTS}"

由于端口8787无法对外访问，因此你必须启用端口转发。启用端口转发后，你创建了一个新的远程 Java 应用程序，将连接到以调试模式运行的 JBoss EAP cartridge。

另见

使用 Eclipse 开发 OpenShift Java 应用程序 配方
使用 Eclipse 系统资源管理器通过 SSH 连接到应用程序 gear 配方

第八章：针对 Python 开发者的 OpenShift

本章提供了一些配方，帮助你开始在 OpenShift 上进行 Python Web 应用开发。本章包含以下配方：

创建你的第一个 Python 应用程序
管理 Python 应用程序的依赖关系
使用 Python 和 PostgreSQL 模块创建和部署 Flask 网络应用程序
启用 Python 应用程序的热部署
强制清除 Python 虚拟环境
访问应用程序的 Python 虚拟环境
在 Python 应用程序中使用 Gevent
安装自定义 Python 包
使用 .htaccess 文件配置 Apache

介绍

Python 是一种通用的高级编程语言，易于使用且非常流行。它是一种解释型语言，强调源代码的可读性，通过严格的缩进来确定代码块。Python 通常用作脚本语言，但它在 Web 应用开发和科学计算领域也非常受欢迎。Python 拥有许多强大的 Web 应用框架，如 Django、Flask、Bottle 和 Tornado，帮助开发者使用 Python 编程语言构建出色的 Web 应用程序。

OpenShift 为 Python Web 开发者提供了一个托管平台，用于部署他们的 Web 应用程序。在撰写本书时，OpenShift 支持三种版本的 Python——2.6、2.7 和 3.3。你可以通过运行以下命令查看所有可用的 Python 版本：

$ rhc cartridges |grep python
python-2.6          Python 2.6                              web
python-2.7          Python 2.7                              web
python-3.3          Python 3.3                              web

创建你的第一个 Python 应用程序 配方将帮助你迈出在 OpenShift 上开发 Python 应用程序的第一步。OpenShift 支持 Apache 和 mode_wsgi HTTP 服务器模块（code.google.com/p/modwsgi/）来运行你的 Python Web 应用程序。Python 应用程序可以选择任何受支持的版本，并在虚拟环境工具（virtualenv）中运行。虚拟环境工具是你 Python 安装的隔离和私有副本，它只会用于该项目，而不会影响系统的全局 Python 安装。访问应用程序的 Python 虚拟环境 配方将教你如何通过 SSH 连接到应用程序的设备，访问虚拟环境。

我们还将介绍在 Python 应用程序中管理应用依赖关系的不同方法。你可以使用 requirements.txt 或 setup.py 或两者结合来管理应用的依赖关系。这将会在管理 Python 应用程序依赖关系配方中进行讲解。

本章中的示例应用程序将使用 Flask Web 框架和 PostgreSQL 数据库进行开发。我选择 Flask 是因为它的流行和易用性。你也可以使用其他任何 Web 框架，如 Bottle、web2py 和 Django。使用 Python 和 PostgreSQL 插件创建和部署 Flask Web 应用程序 这一部分将逐步讲解如何在 OpenShift 上编写 Flask Web 应用程序。所有源代码都可以在 OpenShift-Cookbook GitHub 组织中找到 (github.com/OpenShift-Cookbook)。

使用独立的 WSGI 服务器，如 Gevent 或 Gunicorn，也可以与 OpenShift Python 应用程序一起使用。在 Python 应用程序中使用 Gevent 这一部分将详细讲解这一内容。

如果你想在本地机器上运行示例，请安装 Python、pip 和 virtualenv。pip 是一个用于安装和管理 Python 包的命令行工具。你可以在 docs.python-guide.org/en/latest/index.html 查找为你的操作系统安装 Python 的说明。在 pip.readthedocs.org/en/latest/installing.html 可以找到安装 pip 的说明。最后，你可以通过参考 docs.python-guide.org/en/latest/dev/virtualenvs/ 中提到的说明，在你的机器上安装 virtualenv。

本章假设你已经熟悉 Python Web 开发基础、OpenShift 应用程序基础，以及如何使用 OpenShift 数据库插件。如果你对这些主题不太熟悉，建议你先阅读第三章，创建和管理应用程序，以及第六章，在 OpenShift 应用程序中使用 MongoDB 和第三方数据库插件，然后再继续阅读本章内容。

创建你的第一个 Python 应用程序

在本节中，你将学习如何使用 rhc 命令行工具创建一个 OpenShift Python 应用程序。我们将创建一个 Python 3.3 应用程序，然后了解 OpenShift 创建的模板应用程序。

准备工作

要完成本节的操作，你需要在你的机器上安装 rhc 命令行客户端。有关详细信息，请参考第一章，开始使用 OpenShift 中的 安装 OpenShift rhc 命令行客户端 部分。

如何操作…

执行以下步骤，创建你的第一个 Python 应用程序：

打开一个新的命令行终端，并将目录切换到你希望创建应用程序的方便位置。
要创建一个新的 Python 3.3 应用程序，请运行以下命令：
```
$ rhc create-app myapp python-3.3
```
你可以用 Python 2.6 或 Python 2.7 替换 Python 3.3，来创建使用相应 Python 版本的应用程序。
打开你最喜欢的网页浏览器，访问 http://myapp-{domain-name}.rhcloud.com 来查看应用程序。请将 {domain-name} 替换为你的 OpenShift 账户域名。你将看到如下所示的 OpenShift 模板应用程序：

它是如何工作的……

当你运行 rhc create-app 命令时，OpenShift 经纪人将接收请求并启动应用程序创建过程。应用程序创建过程在第三章 创建和管理应用程序 的 使用 rhc 命令行客户端创建 OpenShift 应用程序 一节中有详细说明。要运行你的 Python 应用程序，OpenShift 需要知道你希望使用的 Python 版本。在步骤 2 中，你指定了 OpenShift 应该创建一个 Python 3.3 应用程序，并将 myapp 作为应用程序名称。OpenShift 将使用这些信息以及一些默认值来创建 myapp 应用程序。默认值包括小型机种、不可扩展的应用程序，并使用当前目录来克隆 Git 仓库。要运行基于 Python-3.3 的网络应用程序，OpenShift 将安装 Python 3.3 语言运行时，并配置 Apache 服务器与 mod_wsgi 模块。mod_wsgi 模块提供了 Web 服务器网关接口（WSGI）规范的实现，使 Apache 网络服务器能够托管支持 Python WSGI 接口的 Python 网络应用程序。WSGI 规范描述了 Web 服务器与 Web 应用程序或框架之间的简单接口，适用于 Python 编程语言。Python 社区中大多数流行的 Web 框架（wsgi.readthedocs.org/en/latest/frameworks.html）都支持 WSGI 接口。这使得开发人员可以轻松地在 OpenShift 上运行他们选择的框架，因为它提供了 Apache mod_wsgi 部署环境。

注意

你也可以在其他 Python 网络服务器上运行 Python 网络应用程序，例如 Gevent。有关内容将在 使用 Gevent 与 Python 应用程序 这一食谱中介绍。

除了安装 Python 并使用 mod_wsgi 配置 Apache，每个 OpenShift 应用程序都使用 virtualenv 和 pip 来管理应用程序的依赖关系。virtualenv 工具是你 Python 安装的一个隔离和私有副本，仅用于该项目，不会影响系统的全局 Python 安装。你可以使用 pip 在 virtualenv 工具中安装包，virtualenv 将确保应用程序只访问它所需的包。虚拟环境的另一个优点是它们不需要管理员权限。

现在，让我们看看 OpenShift 创建的模板应用程序，如下所示：

$ cd myapp && ls -ap
$ .git/.openshift/ requirements.txt   wsgi.py  setup.py

模板应用程序有三个文件——requirements.txt、wsgi.py 和 setup.py，此外还有 .openshift 和 .git 目录。我们在第三章的 使用 rhc 命令行客户端创建 OpenShift 应用程序 章节中已经讨论过 .openshift 和 .git，所以这里就不再赘述。接下来，我们逐个讨论这三个应用程序文件：

requirements.txt：requirements.txt 文件用于指定应用程序依赖的库。pip 包管理器将安装 requirements.txt 中列出的所有应用程序依赖项。这是一个普通的文本文件，每行列出一个依赖项。格式为 [package name]==[package version]。下面是一个示例 requirements.txt 文件：
```
Flask==0.10.1
Jinja2==2.7.2
MarkupSafe==0.21
Werkzeug==0.9.4
itsdangerous==0.24
```

setup.py：setup.py 文件使开发人员能够更轻松地构建和分发 Python 包，这些包将被其他项目作为依赖项导入。它允许你指定项目特定的元数据，如名称和描述，并指定依赖项。下面是一个示例 setup.py 文件：

from setuptools import setup
setup(name='MyAwesomeApp',
      version='1.0',
      description='My Awesome OpenShift Application',
      author='Shekhar Gulati',
      author_email='shekhargulati84@gmail.com',
      url='http://www.python.org/sigs/distutils-sig/',
      install_requires=['Flask>=0.7.2', 'MarkupSafe'],
      )

wsgi.py：wsgi.py 文件是由 OpenShift 创建的一个 WSGI 兼容的应用程序文件。如果你想使用 Apache mod_wsgi 服务器来托管 Python Web 应用程序，则该文件是必需的。这个文件包含了 mod_wsgi 模块的代码，启动时会执行该代码以获取应用程序对象。应用程序对象是一个可调用的对象，接受两个参数——environ 和 start_response。environ 参数是一个字典，包含了环境变量，而 start_response 是一个可调用对象，接受两个必需的参数：status 和 response_headers。

你可以通过运行以下命令来检查应用程序环境中运行的 Python 的确切版本：

$ rhc ssh --command 'python -V'
Python 3.3.2

还有更多内容...

默认情况下，Python 应用程序期望 wsgi.py 文件位于应用程序的根目录。如果你想更改目录结构并为 wsgi.py 设置不同的位置，可以通过设置 OPENSHIFT_PYTHON_WSGI_APPLICATION 环境变量来指定一个不同的位置，如下所示。你可以在 access.redhat.com/documentation/en-US/OpenShift_Online/2.0/html/User_Guide/Python_Environment_Variables.html 查看 Python 应用程序的环境变量列表。

$ rhc env-set OPENSHIFT_PYTHON_WSGI_APPLICATION=wsgi/wsgi.py

参见

管理 Python 应用程序依赖 章节
启用 Python 应用程序的热部署 章节
使用 Python 和 PostgreSQL 套件创建和部署 Flask Web 应用程序 章节

管理 Python 应用程序依赖

OpenShift 为 Python 开发者提供了两种指定应用程序依赖关系的方式。您可以在setup.py文件中的install_requires元素、requirements.txt文件中，或两者中指定应用程序依赖关系。当依赖关系在setup.py和requirements.txt文件中同时指定时，OpenShift 将安装这两个文件中列出的所有库。当您想将库作为包分发给他人使用时，setup.py文件是必需的。PyPi 上的所有包都需要在其根目录中包含setup.py脚本。由于您不打算将您的 Web 应用程序作为包分发，因此不需要使用setup.py文件。我建议您为 OpenShift 应用程序使用requirements.txt。setup.py之所以存在，是因为 OpenShift 最初仅支持setup.py，后来才添加了对requirements.txt文件的支持。因此，为了确保现有的应用程序在 OpenShift 上继续正常运行，我们需要支持这两种方式。在本食谱中，您将学习如何使用requirements.txt来指定应用程序依赖关系。此食谱中创建的应用程序源代码可以在 GitHub 上找到（github.com/OpenShift-Cookbook/chapter8-recipe2）。

准备工作

本食谱假设您已经阅读了创建您的第一个 Python 应用程序食谱。为了跟随本食谱，您需要在您的机器上安装 rhc 命令行客户端。请参考第一章中的安装 OpenShift rhc 命令行客户端食谱，了解详细信息。本食谱还要求您在机器上安装 virtualenv。您可以通过访问docs.python-guide.org/en/latest/dev/virtualenvs/中的说明来安装 virtualenv。

如何操作…

执行以下步骤来构建一个Hello World Flask Web 应用程序，演示如何处理应用程序依赖关系：

打开一个新的命令行终端，并运行以下命令来创建一个新的 Python 应用程序：
```
$ rhc create-app myapp python-3.3
```
如果您想创建 Python 2.6 或 Python 2.7 应用程序，请使用python-2.6或python-2.7作为 Web cartridge 名称，而不是python-3.3。
将目录切换到myapp，并按如下方式删除setup.py文件：
```
$ cd myapp
$ rm –f setup.py
```
运行以下命令创建一个新的虚拟环境：
```
$ virtualenv venv --python=python3.3
```
在开始使用虚拟环境之前，您需要先激活它。要激活虚拟环境，请运行以下命令：
```
$ . venv/bin/activate
```
激活 virtualenv 后，您可以开始安装模块，而不会影响系统的默认 Python 解释器。通过运行以下命令安装 Flask 模块：
```
$ pip install flask
```

在 myapp 目录中创建一个名为 hello.py 的新 Python 文件，并在其中填入以下代码：

from flask import Flask
app = Flask(__name__)

@app.route('/')
def index():
  return 'Hello World!'

if __name__ == '__main__':
  app.run()

要在本地机器上运行此应用程序，请运行以下命令：
```
$ python hello.py
```
接下来，打开你喜欢的 Web 浏览器，访问 http://127.0.0.1:5000。你将看到浏览器中显示 Hello World!。
要将此应用程序部署到 OpenShift，我们需要在 requirements.txt 中声明所有依赖项。以下命令将把所有应用程序的依赖项写入 requirements.txt 文件：
```
$ pip freeze > requirements.txt
```
上述命令会将所有应用程序依赖项添加到 requirements.txt 文件中。这也包括传递性依赖项。requirements.txt 文件将如下所示：
```
Flask==0.10.1
Jinja2==2.7.2
MarkupSafe==0.23
Werkzeug==0.9.4
distribute==0.7.3
itsdangerous==0.24
```
注意

请确保 distribute 的版本是 0.7.3，因为早期版本与 Python 3.3 不兼容。如果使用早期版本的 distribute，你可能会遇到问题。
此外，我们需要更新 wsgi.py 文件，以便加载 Flask 应用程序，而不是 OpenShift 默认创建的应用程序。在 wsgi.py 文件中删除所有内容，并用以下代码替换：
```
#!/usr/bin/env python
from hello import app as application
```
在 myapp 目录中创建一个名为 .gitignore 的新文件，并将 venv 目录添加到忽略列表中。我们不希望将虚拟环境推送到 OpenShift；OpenShift 会根据 requirements.txt 文件中列出的依赖关系来创建虚拟环境。.gitignore 文件的内容如下：
```
$ cat .gitignore 
venv/
```
现在将代码提交到本地仓库，然后将更改推送到应用程序 gear。OpenShift 会安装 requirements.txt 文件中指定的所有包，并通过虚拟环境将它们提供给应用程序，具体操作如下：
```
$ git add .
$ git commit -am "Hello World Flask application"
$ git push
```
现在，你可以在 http://myapp-{domain-name}.rhcloud.com 查看应用程序运行情况。请将 {domain-name} 替换为你的应用程序域名。你将在浏览器中看到 Hello World。

它是如何工作的……

在之前的步骤中，你创建了一个简单的 Flask 框架 Web 应用程序，该应用程序使用 requirements.txt 来指定应用程序的依赖项。Flask 是 Python 编程语言的一个微型 Web 框架。它是一个易于学习的框架，且文档齐全，文档可以在 flask.pocoo.org/docs 找到。

在第 1 步中，你创建了一个名为 myapp 的 Python 3.3 应用程序。请阅读 创建你的第一个 Python 应用程序 配方，了解 OpenShift 创建的 Python 应用程序。由于你将使用 requirement.txt 来指定应用程序依赖项，因此在第 2 步中删除了 setup.py 文件。如果愿意，你可以保留 setup.py 文件，并在其中指定应用程序的元数据。应用程序元数据包括应用程序的名称、描述、版本等。我建议你仅在一个文件中指定应用程序依赖项，以避免出现依赖地狱 (en.wikipedia.org/wiki/Dependency_hell)。

第 3 步使用 Python 3.3 解释器创建了一个新的虚拟环境。要使用虚拟环境，你必须首先使用第 4 步中显示的命令激活它。虚拟环境是处理 Python 应用程序的理想方式，因为它避免了污染系统全局的 Python 安装。

你在第 5 步使用 pip 安装了 Flask web 框架，因为我们将开发一个使用该框架的 web 应用程序。Flask 框架将被安装在虚拟环境中，并将可供你的应用程序使用。

在第 6 步，你创建了一个新的 Python 文件 hello.py，并添加了 Hello World 应用程序的源代码。第 6 步中显示的代码执行了以下操作：

在第 1 行，你从 flask 模块中导入了 Flask 类。
在第 2 行，你创建了一个 Flask 类的实例。这个实例将成为 WSGI 应用程序的实例。
然后，你为根目录（/）URL 定义了一个路由。该路由告诉 Flask 框架，当请求根 URL 时，应该调用 index() 函数。index() 函数将简单地在浏览器中渲染 Hello World!。
最后，如果应用程序模块的名称等于 '__main__'，开发服务器将启动。__name__ == '__main__' 表达式用于确保只有在直接使用 python hello.py 命令执行脚本时，开发服务器才会启动。

第 7 步通过执行 hello.py 脚本启动了开发 web 服务器。这将启动开发服务器并启动 Flask 应用程序。

在第 8 步，你使用 pip freeze 命令将所有依赖项添加到 requirements.txt 文件中。OpenShift 将下载该文件中提到的所有依赖项，并将它们填充到应用程序的虚拟环境中。OpenShift 使用 Apache 的 mod_wsgi 来运行你的 Python 应用程序。mod_wsgi 的入口点是 wsgi.py 文件。这个文件应该包含在启动时提供应用程序对象的代码。在第 9 步，你替换了 wsgi.py 文件的内容，使其使用 Flask 应用程序对象，而不是模板创建的应用程序对象。

最后，你将代码提交到本地 Git 仓库，并将代码推送到 OpenShift 应用程序环境中。OpenShift 首先会停止 Apache 服务器，下载 requirements.txt 文件中提到的所有依赖项并将它们安装到虚拟环境中，然后最终启动 Apache 服务器。git push 输出的一部分如下所示：

$ git push
Counting objects: 9, done.
Writing objects: 100% (6/6), 695 bytes, done.
Total 6 (delta 0), reused 0 (delta 0)
remote: Stopping Python 3.3 cartridge
remote: Building git ref 'master', commit 128311d
remote: Activating virtenv
remote: Checking for pip dependency listed in requirements.txt file..
remote: Downloading/unpacking Flask==0.10.1 (from -r /var/lib/openshift/536f59b3e0b8cd628600138b/app-root/runtime/repo/requirements.txt (line 1))
remote: Downloading/unpacking Jinja2==2.7.2 (from -r /var/lib/openshift/536f59b3e0b8cd628600138b/app-root/runtime/repo/requirements.txt (line 2))
…
remote: Successfully installed Flask Jinja2 MarkupSafe Werkzeug itsdangerous setuptools distribute
remote: Cleaning up...
remote: Starting Python 3.3 cartridge (Apache+mod_wsgi)
remote: Application directory "/" selected as DocumentRoot
remote: Application "wsgi.py" selected as default WSGI entry point
remote: Deployment completed with status: success

还有更多内容...

如果你希望使用 setup.py 而不是 requirements.txt，可以删除 requirements.txt 文件，或者保持为空，并在 install_requires 元素下指定所有依赖项，如下所示。应用程序的完整源代码可以在 GitHub 上查看：github.com/OpenShift-Cookbook/chapter8-recipe2-setup.py。

from setuptools import setup

setup(name='MyApp',
      version='1.0',
      description='My OpenShift App',
      author='Shekhar Gulati',
      author_email='shekhargulati84@gmail.com',
      url='http://www.python.org/sigs/distutils-sig/',
     install_requires=['Flask>=0.10.1'],
     )

另见

创建你的第一个 Python 应用 这个配方
启用 Python 应用的热部署 这个配方
使用 Python 和 PostgreSQL 插件创建和部署 Flask 网络应用 这个配方

使用 Python 和 PostgreSQL 插件创建和部署 Flask 网络应用

在本配方中，你将使用 Python Flask 网络框架（flask.pocoo.org/）和 PostgreSQL 数据库开发一个简单的职位门户应用。我选择 Flask 是因为它是一个非常易于使用且流行的网络框架。你可以在 OpenShift 上运行任何网络框架，如 Django、Bottle、Zope 和 Tornado。示例应用将允许用户发布职位空缺并查看系统中所有已保存职位的列表。这两个功能将通过两个 REST 端点提供。此配方的源代码可在 GitHub 上找到：github.com/OpenShift-Cookbook/chapter8-jobstore-simple。

准备工作

本配方假设你已经阅读了本章前面的配方。要执行此配方，你需要在计算机上安装 rhc 命令行客户端。有关详细信息，请参考第一章中的 安装 OpenShift rhc 命令行客户端 配方。此外，如果你想在本地机器上运行应用，你需要安装 Python、pip 和 virtualenv。请参考引言部分获取安装说明的链接。

如何操作…

要创建应用，执行以下步骤：

打开一个新的命令行终端，并导航到你希望创建应用的便捷位置。创建一个新的 Python 2.7 和 PostgreSQL 9.2 OpenShift 应用，并输入以下命令：
```
$ rhc create-app jobstore python-2.7 postgresql-9.2
```
创建应用后，切换到 jobstore 目录，并删除 setup.py 文件：
```
$ cd jobstore
$ rm -f setup.py
```
同时，创建一个 .gitignore 文件，并将以下内容添加到其中：
```
venv/
*.pyc
```
为 jobstore 应用创建一个新的虚拟环境。运行以下命令创建虚拟环境，然后激活它：
```
$ virtualenv venv --python=python2.7
$ . venv/bin/activate
```
现在虚拟环境已激活，你可以安装应用的依赖项。此应用使用 Flask 网络框架。要在虚拟环境中安装依赖项，运行以下命令：
```
$ pip install flask
```

创建一个名为 jobstore.py 的新文件，用于存放应用的源代码。以下代码是一个简单的 Flask 应用，当请求根 URL 时，它会渲染一个 index.html 文件：

from flask import Flask, render_template,jsonify, request, Response

app = Flask(__name__)
app.config['PROPAGATE_EXCEPTIONS'] = True

@app.route('/')
def index():
  return render_template('index.html')

if __name__ == '__main__':
  app.run(debug=True)

在之前的代码中，索引路由将在请求根 URL 时渲染 index.html。默认情况下，Flask 会在应用程序文件夹内的 templates 目录中查找模板。Flask 框架提供的 render_template() 函数将 Jinja 2 模板引擎集成到应用程序中。为了确保此代码能正常工作，在应用程序源代码仓库中创建一个名为 templates 的新目录，如下所示：
```
$ mkdir templates
```

现在，在 templates 目录中创建一个新的 index.html 文件，并添加以下内容：

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>JobStore</title>
<link href="//cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.1.1/css/bootstrap.css" rel="stylesheet">
</head>
<body>
  <div class="container">
    <div class="row">
      <h2>JobStore application expose Two REST End Points</h2>
      <ul>
        <li>
          To create a Job, make a HTTP POST request to <code>/api/v1/jobs</code>
        </li>
        <li>
          To view all Jobs, make a HTTP GET request to <code>/api/v1/jobs</code>
        </li>
      </ul>
    </div>
  </div>

</body>
</html>

你可以通过运行以下命令来启动 Python 服务器，测试应用程序：
```
$ python jobstore.py
```
要查看应用程序，打开你喜欢的浏览器，访问 http://127.0.0.1:5000/。你将看到浏览器中渲染的 index.html。
该应用程序的主要职责是将工作数据存储到数据库中。Python 为多种数据库框架提供了支持功能，使得操作各种数据库变得非常容易。其中，SQLAlchemy 是最受欢迎且功能强大的关系型数据库框架，支持多种 RDBMS 后端。要在 Flask 应用程序中使用 SQLAlchemy，你首先需要安装 Flask SQLAlchemy 扩展。Flask SQLAlchemy 扩展简化了在 Flask 应用程序中使用 SQLAlchemy 的工作。要安装 Flask SQLAlchemy，可以运行以下 pip 命令：
```
$ pip install flask-sqlalchemy
```
现在你已经安装了 Flask SQLAlchemy 扩展，下一步是编写配置代码，以便 jobstore 应用程序能够连接到 PostgreSQL 数据库。将以下内容添加到 jobstore.py 中。你可以在 GitHub 上查看完整的源代码：github.com/OpenShift-Cookbook/chapter8-jobstore-simple/blob/master/jobstore.py。
```
from flask.ext.sqlalchemy import SQLAlchemy

app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['OPENSHIFT_POSTGRESQL_DB_URL']
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True

db = SQLAlchemy(app)
```
在前面的代码中，你向 Flask 应用程序配置对象添加了两个配置选项。SQLALCHEMY_DATABASE_URI 指向数据库连接 URL。OpenShift 使用 OPENSHIFT_POSTGRESQL_DB_URL 环境变量公开 PostgreSQL 数据库连接 URL。SQLALCHEMY_COMMIT_ON_TEARDOWN 选项启用在每个请求结束时自动提交数据库更改。最后，你实例化了来自 SQLAlchemy 类的 db 对象，并将应用程序对象传递给它。这个 db 对象提供了所有与数据库相关的功能。

接下来，你将编写一个模型类来表示 PostgreSQL 数据库中的 Job 表。模型表示存储在数据库中的持久化实体。我们在第 7 步中获得的 db 实例提供了一个可以扩展的基类。除此之外，db 对象还提供了帮助函数来定义模型类的结构。Job 模型如下所示：

class Job(db.Model):
  __tablename__ = 'jobs'
  id = db.Column(db.Integer(), primary_key=True)
  title = db.Column(db.String(64), index=True, nullable=False)
  description = db.Column(db.Text())
  posted_at = db.Column(db.DateTime(), nullable=False, default=datetime.utcnow)
  company = db.Column(db.String(100), nullable=False)

  def __repr__(self):
    return 'Job %s' % self.title

  def to_json(self):
    job_json = {
      'id' : self.id,
      'title': self.title,
      'description' : self.description,
      'posted_at' : self.posted_at,
      'company':self.company
    }
    return job_json

  @staticmethod
  def from_json(job_json):
    title = job_json.get('title')
    description = job_json.get('description')
    company = job_json.get('company')
    return Job(title=title, description=description,company=company)

__tablename__ 变量用于定义数据库中表的名称。db.Column() 函数用于定义类变量，这些变量将映射到数据库表中的列。你还定义了几个帮助函数，帮助进行 JSON 转换。这些方法在我们构建 REST API 时将非常有用。

现在，你将编写几个 REST 端点来暴露一些功能。第一个端点将允许用户列出数据库中的所有职位，第二个端点将允许用户创建一个新职位。REST 端点如下所示：
```
@app.route('/api/v1/jobs')
def all_jobs():
  jobs = Job.query.all()
  return jsonify({'jobs':[job.to_json() for job in jobs]})

@app.route('/api/v1/jobs', methods=['POST'])
def post_job():
  job = Job.from_json(request.json)
  db.session.add(job)
  db.session.commit()
  return jsonify(job.to_json()) , 201
```
在前面的代码中，all_jobs() 函数从数据库中查询所有的 Job 行。数据库返回的结果被转换为 JSON 格式并返回给用户。jsonify() 函数是 Flask 提供的，它会创建一个带有 JSON 表示和 application/json MIME 类型的响应。

post_job() 函数首先将 JSON 请求转换为 Job 对象，然后将其写入数据库。最后，它会将持久化的职位返回给用户。

如在 管理 Python 应用程序依赖项 章节中讨论的，你必须更新 wsgi.py 文件，以加载 Flask 应用程序，而不是 OpenShift 默认创建的应用程序。删除 wsgi.py 文件中的所有内容，并用以下代码替换：

#!/usr/bin/python
import os
virtenv = os.environ['OPENSHIFT_PYTHON_DIR'] + '/virtenv/'
virtualenv = os.path.join(virtenv, 'bin/activate_this.py')
try:
    execfile(virtualenv, dict(__file__=virtualenv))
except IOError:
    pass
from jobstore import app as application
from jobstore import *
db.create_all()

在我们部署应用程序之前，最后一步是指定 requirements.txt 中的依赖项。运行以下命令来填充应用程序的 requirements.txt 文件：
```
$ pip freeze > requirements.txt
```
现在，提交代码并将应用程序更改推送到应用程序 gear，如下所示：
```
$ git add .
$ git commit -am "jobstore application created"
$ git push
```
应用程序将在 http://jobstore-{domain-name}.rhcloud.com 启动并运行。

要测试 REST 端点，你可以使用 cURL。要创建一个新的 Job 实例，请运行以下 cURL 命令：

$ curl -i -X POST -H "Content-Type: application/json" -H "Accept: application/json" -d '{"title":"OpenShift Evangelist","description":"OpenShift Evangelist","company":"Red Hat"}' http://jobstore-{domain-name}.rhcloud.com/api/v1/jobs

要查看所有的职位，可以运行以下 cURL 命令：
```
$ curl http://jobstore-osbook.rhcloud.com/api/v1/jobs
```

它是如何工作的……

在前面的步骤中，你创建了一个 Python Web 应用程序并将其部署到 OpenShift。从步骤 1 到 4，你首先创建了一个新的 Python 2.7 OpenShift 应用程序，为项目创建了一个虚拟环境，并最终激活了虚拟环境。该应用程序使用 Python Flask 框架，因此你在步骤 5 中通过 pip 安装了它。

在步骤 6 到 8 中，你创建了一个 Flask Web 应用程序，该应用程序渲染 index.html 文件。步骤 4 中显示的代码执行了以下操作：

你导入了所有必需的类和函数。
然后，你创建了一个 Flask 类的实例。唯一需要的参数是应用程序的主模块或包的名称。在大多数情况下，正确的值是 __name__。接着，你使用 app.route 装饰器为根 URL 定义了一个路由。路由允许你根据请求的 URL 将 HTTP 请求绑定到函数调用。index 函数将在浏览器中渲染 index.html 文件。
最后，如果应用模块的名称等于'__main__'，则启动开发服务器。__name__ == '__main__'表达式用于确保只有在通过python jobstore.py命令直接执行脚本时，才启动开发服务器。你在第 10 步中在本地机器上测试了该应用程序。

在第 11 至第 14 步中，你首先安装了 Flask SQLAlchemy 扩展，然后执行了以下操作：

首先，你从Flask-SQLAlchemy扩展中导入了SQLAlchemy类。
接着，你使用 Flask 配置对象中的SQLALCHEMY_DATABASE_URI配置了应用数据库的 URL。你还使用了另一个有用的选项SQLALCHEMY_COMMIT_ON_TEARDOWN，配置了在每个请求结束时自动提交数据库更改。
接下来，你创建了一个SQLAlchemy类的实例，该实例提供对所有 SQLAlchemy API 的访问。
接着，你使用 SQLAlchemy API 定义了Job模型类。company类继承了db.Model基类，并使用db.Column构造函数定义了模型类的结构。__tablename__变量用于定义数据库中表的名称。
最后，你定义了一些辅助函数，帮助在 JSON 与其他格式之间转换。这些方法在我们构建 REST API 时非常有用。

在第 15 步中，你为Job模型类定义了 REST 端点。第 15 步中的代码列表执行了以下操作：

当用户向/api/v1/jobs发送GET请求时，将调用all_jobs()函数。该函数通过 SQLAlchemy API 查找所有的工作记录，遍历结果集，然后将其转换为 JSON 格式。
当用户向/api/v1/jobs发送POST请求时，将创建一个新工作。JSON 数据作为request.json Python 字典暴露出来。然后，request.json字典通过from_json方法转换为Job对象。数据随后通过db.session API 持久化到数据库中。

在第 16 步中，你替换了wsgi.py文件的内容，使其使用 Flask 应用对象，而不是模板中创建的应用对象。最后，你将代码提交到本地 Git 仓库，然后将更改推送到 OpenShift 应用程序设备。一旦部署完成，你可以访问http://jobstore-{domain-name}.rhcloud.com并使用该应用程序。

还有更多

你可以通过一个命令完成之前执行的所有步骤。命令中提到的 Git 仓库包含此食谱的源代码，如下所示：

$ rhc create-app jobstore python-2.7 postgresql-9.2 --from-code https://github.com/OpenShift-Cookbook/chapter8-jobstore-simple.git

另请参见

创建你的第一个 Python 应用程序食谱
为 Python 应用程序启用热部署食谱

为 Python 应用程序启用热部署

每次你修改应用程序源代码并将更改推送到 OpenShift 应用程序服务器的 Git 仓库时，OpenShift 首先会停止你的服务器（这会停止所有安装在服务器上的组件），然后将源代码从应用程序 Git 仓库复制到 app-root/runtime/repo，进行构建，准备工件，最后启动服务器（这会启动所有组件）。这个过程需要时间，不适合快速开发和部署。为了实现快速开发和更快速的部署，OpenShift 支持热部署。热部署意味着你可以在不需要重启所有应用程序组件的情况下部署你的更改。

在本教程中，你将学习如何为 Python 应用程序启用热部署。

注意

这个教程适用于所有三个支持的 Python 版本。

如何操作……

执行以下步骤为你的应用程序启用热部署：

使用前面教程中开发的源代码，创建一个新的 Python 应用程序，方法如下：

$ rhc create-app myapp python-3.3 --from-code=https://github.com/OpenShift-Cookbook/chapter8-recipe2.git

打开 hello.py 文件，并将 Hello World! 更新为 Hello from OpenShift。
要启用热部署，在 .openshift/markers 目录下创建一个名为 hot_deploy 的空文件。这个文件被称为标记文件，因为它不包含任何内容。在 *nix 系统中，你可以通过执行以下命令来创建一个新文件。在 Windows 系统中，你可以使用文件资源管理器创建一个新文件。
```
$ touch .openshift/markers/hot_deploy
```
将文件添加到 Git 仓库，然后提交并推送更改到应用程序服务器，如以下代码所示：
```
$ git add –A .
$ git commit -am "enabled hot deployment"
$ git push
```
在 git push 日志中，你会看到一条信息，说明因为启用了热部署，所以组件没有停止，如下所示：
```
remote: Not stopping cartridge python because hot deploy is enabled
```
现在，在你喜欢的网页浏览器中打开应用程序 URL，你会看到更改已部署而无需重启。

它是如何工作的……

hot_deploy 标记文件的存在告知 OpenShift 你想要进行热部署。在停止并重新启动应用程序组件之前，OpenShift 会检查 hot_deploy 标记文件是否存在。如果 hot_deploy 标记文件存在，OpenShift 将不会停止组件，且更改将无需重启组件就会部署。热部署非常适合开发过程，我建议你在开发过程中始终使用它。

注意

如果你启用了热部署并设置了新的环境变量或安装了新的组件，你需要重启应用程序，以便服务器能读取新的环境变量。

另请参见

强制清理 Python 虚拟环境 教程
访问应用程序的 Python 虚拟环境 教程

强制清理 Python 虚拟环境

第一次将更改推送到应用程序 gear 时，pip 会下载 setup.py 或 requirements.txt 中提到的所有依赖项，并用这些依赖项填充虚拟环境。在随后的每次推送中，OpenShift 会重用已有的依赖项，仅下载 setup.py 或 requirements.txt 中提到的新依赖项。这样可以加快应用程序的构建速度，因为它不必在每次 git push 时都下载依赖项。有些情况下，比如虚拟环境损坏，你可能希望重新创建虚拟环境并重新下载所有依赖项。在本配方中，你将学习如何强制 OpenShift 重新创建虚拟环境。

准备工作

本配方假设你已经阅读了本章中的前几个配方。要按步骤操作本配方，你需要在机器上安装 rhc 命令行客户端。有关详细信息，请参阅第一章中的 安装 OpenShift rhc 命令行客户端 配方。

如何操作…

通过运行以下命令，重新创建你在 使用 Python 和 PostgreSQL 托管环境创建和部署 Flask Web 应用程序 配方中开发的应用程序：
```
$ rhc create-app jobstore python-2.7 postgresql-9.2 --from-code https://github.com/OpenShift-Cookbook/chapter8-jobstore-simple.git
```
在应用程序的 .openshift/markers 目录中创建一个名为 force_clean_build 的标记文件。在 *nix 系统上，你可以使用 touch 命令，如下所示：
```
$ cd jobstore
$ touch .openshift/markers/force_clean_build
```
提交该文件，并将更改推送到 OpenShift 应用程序的 gear。从现在开始，每次 git push 都会进行干净的部署。可以通过以下命令来演示：
```
$ git add .
$ git commit –am "enabled force_clean_build"
$ git push
```

它是如何工作的…

force_clean_build 标记文件的存在通知 OpenShift 你希望进行干净的构建。当你执行 git push 时，OpenShift 会首先重新创建虚拟环境，激活环境，最后使用 pip 包管理器下载所有依赖项。你将在 git push 的日志中看到以下日志消息：

remote: Force clean build enabled - cleaning dependencies

另见

启用 Python 应用程序的热部署 配方
强制清除 Python 虚拟环境 配方

访问应用程序的 Python 虚拟环境

到现在为止，你应该已经意识到，每个 OpenShift Python 应用程序都有一个与之关联的虚拟环境。你的应用程序只能使用虚拟环境中可用的依赖项。在本配方中，你将学习如何访问 OpenShift Python 应用程序的虚拟环境。

准备工作

本配方假设你已经阅读了本章之前的配方。要按照此配方操作，你需要在机器上安装 rhc 命令行客户端。详情请参阅第一章中的安装 OpenShift rhc 命令行客户端配方，OpenShift 入门部分。此外，如果你想在本地机器上运行该应用，你需要在机器上安装 Python、pip 和 virtualenv。安装说明可以在引言部分找到相关链接。

如何操作…

执行以下步骤以访问 Python 应用的虚拟环境：

通过运行以下命令，重新创建你在使用 Python 和 PostgreSQL 托管 Flask Web 应用程序配方中开发的应用：

$ rhc create-app jobstore python-2.7 postgresql-9.2 --from-code https://github.com/OpenShift-Cookbook/chapter8-jobstore-simple.git

切换到jobstore目录，然后通过执行rhc ssh命令 SSH 进入应用服务器。

要访问虚拟环境，运行以下命令：

[536fdb88e0b8cd76ee000262]\> . $VIRTUAL_ENV/bin/activate
(virtenv)[536fdb88e0b8cd76ee000262]\>

一旦进入虚拟环境，你可以使用 pip 手动下载新的依赖包。要安装名为Yolk的命令行工具，运行以下命令。Yolk 可以列出在环境中安装的包。
```
(virtenv)[ 536fdb88e0b8cd76ee000262]\> pip install yolk
```

要列出该虚拟环境中所有已安装的包，运行以下命令。为简洁起见，这里仅展示部分输出。

(virtenv)[ 536fdb88e0b8cd76ee000262]\> yolk -l
Babel           - 0.9.6        - active development (/opt/rh/python27/root/usr/lib/python2.7/site-packages)
Extractor       - 0.6          - active development (/opt/rh/python27/root/usr/lib/python2.7/site-packages)
Flask-SQLAlchemy - 1.0          - active development (/var/lib/openshift/536fdb88e0b8cd76ee000262/app-root/runtime/dependencies/python/virtenv/lib/python2.7/site-packages)

它是如何工作的…

你在第 1 步中创建了一个新的 Python 应用，并在第 2 步中使用 rhc ssh 命令通过 SSH 连接到应用服务器。虚拟环境的位置作为环境变量 $VIRTUAL_ENV 可用。在第 3 步中，你激活了虚拟环境以便使用它。最后，在第 4 步中，你手动使用 pip 命令安装了一个包。安装后，包就可以供应用使用了。

另见

为 Python 应用启用热部署配方
强制清理 Python 虚拟环境配方

使用 Gevent 运行 Python 应用程序

到目前为止，在本章中，你已经使用 Apache 配合mod_wsgi来运行你的 Python 应用程序。也可以使用 OpenShift 运行其他独立的 WSGI 服务器，如 Gevent 和 Gunicorn。在本配方中，你将学习如何使用 Gevent 来运行你的 Python 应用程序。Gevent 是一个基于协程的 Python 网络库，使用 greenlet 提供了一个基于 libevent 事件循环之上的高层同步 API。该仓库的源代码可以在 GitHub 上找到，地址是 github.com/OpenShift-Cookbook/chapter8-gevent-recipe。

准备工作

本食谱假设你已经阅读了本章前面的食谱。要执行此食谱，你需要在你的机器上安装 rhc 命令行客户端。有关详细信息，请参阅第一章中安装 OpenShift rhc 命令行客户端的食谱，开始使用 OpenShift。此外，如果你想在本地机器上运行应用程序，你需要在机器上安装 Python、pip 和 virtualenv。有关这些软件安装说明的链接，请参考介绍部分。

如何操作…

执行以下步骤，使用 Gevent 的独立 WSGI 服务器运行 OpenShift Python 应用程序：

打开一个新的命令行终端，并运行以下命令以创建一个新的 Python 2.7 应用程序：
```
$ rhc app create myapp python-2.7
```
如果你想创建 Python 2.6 或 Python 3.3 应用程序，请分别使用 Python 2.6 和 Python 3.3。
切换到myapp目录，并删除setup.py和wsgi.py文件，如下所示：
```
$ cd myapp
$ rm –f setup.py
$ rm –f wsgi.py
```
通过运行以下命令创建一个新的虚拟环境：
```
$ virtualenv venv --python=python2.7
```
在你可以使用虚拟环境之前，必须先激活它。要激活虚拟环境，请运行以下命令：
```
$ . venv/bin/activate
```
一旦你激活了 virtualenv，就可以开始安装模块，而不会影响系统默认的 Python 解释器。通过运行以下命令来安装 Flask 模块：
```
$ pip install flask
```

在myapp目录中创建一个名为hello.py的新 Python 文件，并用以下代码填充它：

from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
  return 'Hello World!'

if __name__ == '__main__':
  app.run()

接下来，安装 Gevent 库，因为我们希望使用它来运行我们的应用程序，如下所示：
```
$ pip install gevent
```

创建一个名为app.py的新文件，并添加以下代码：

import os
virtenv = os.environ['OPENSHIFT_PYTHON_DIR'] + '/virtenv/'
virtualenv = os.path.join(virtenv, 'bin/activate_this.py')
try:
    execfile(virtualenv, dict(__file__=virtualenv))
except IOError:
    pass

from gevent.wsgi import WSGIServer
from hello import app

ip   = os.environ['OPENSHIFT_PYTHON_IP']
port = int(os.environ['OPENSHIFT_PYTHON_PORT'])

http_server = WSGIServer((ip, port), app)
http_server.serve_forever()

为了将此应用程序部署到 OpenShift，我们需要在requirements.txt中声明所有依赖项。以下命令会将所有应用程序依赖项写入requirements.txt文件：
```
$ pip freeze > requirements.txt
```
上一个命令会将所有应用程序的依赖项填充到requirements.txt文件中。这包括传递依赖项。requirements.txt文件如下所示：
```
Flask==0.10.1
Jinja2==2.7.2
MarkupSafe==0.23
Werkzeug==0.9.4
gevent==1.0.1
greenlet==0.4.2
itsdangerous==0.24
wsgiref==0.1.2
```
在myapp目录中创建一个名为.gitignore的新文件，并将venv目录添加到忽略列表中。我们不希望将虚拟环境推送到 OpenShift，因为 OpenShift 会根据requirements.txt文件中提到的依赖项创建一个虚拟环境。.gitignore文件如下所示：
```
$ cat .gitignore 
venv/
```
现在，将代码提交到本地仓库，然后将更改推送到应用程序 gear。OpenShift 将安装requirements.txt中指定的所有包，并通过虚拟环境使它们对应用程序可用，如下所示：
```
$ git add .
$ git commit -am "using Gevent standalone WSGI server"
$ git push
```
现在，打开你喜欢的浏览器，访问 Web 应用程序的 URL，查看应用程序的运行效果。你将在浏览器中看到Hello World文本。

它是如何工作的…

在第 1 到第 6 步中，你创建了一个简单的 Flask web 应用程序，如 管理 Python 应用程序依赖项 这道菜谱中所述。由于我们将使用 Gevent 来运行此应用程序，你在第 7 步安装了 Gevent 库。在第 8 步，你创建了一个新的 Python 文件 app.py。如果用户没有使用默认的 wsgi.py 文件或通过 OPENSHIFT_PYTHON_WSGI_APPLICATION 环境变量配置的 WSGI 端点，OpenShift 将使用 app.py 文件中配置的服务器来提供服务。此 Python 文件应命名为 app 并存在于 app 根目录下。app.py 文件中的代码首先激活虚拟环境，然后在 $OPENSHIFT_PYTHON_IP 和 $OPENSHIFT_PYTHON_PORT 启动 Gevent WSGI 服务器。

在第 9 步中，你使用 pip freeze 命令将所有依赖项添加到 requirements.txt 文件中。OpenShift 将下载此文件中提到的所有依赖项，并将它们填充到应用程序的虚拟环境中。

最后，你将代码提交到本地 Git 仓库，并将其推送到 OpenShift 应用程序的 gear 上。OpenShift 将使用 Gevent WSGI 服务器来运行你的应用程序。在 git push 的日志中，你将看到如下命令行输出的一行。以下这一行清楚地告诉你，OpenShift 正在使用 app.py 中配置的服务器：

remote: Starting Python 2.7 cartridge (app.py server)

还有更多...

同样，你也可以使用 Tornado web 服务器来提供 Python web 应用程序。卸载 Gevent 和 greenlet 库，然后安装 Tornado 库：

$ pip uninstall gevent greenlet
$ pip install tornado

通过运行 pip freeze > requirements.txt 命令，将依赖项更新到 requirements.txt 文件中。

在 app.py 文件中，将 Gevent 代码替换为以下代码：

from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from hello import app

http_server = HTTPServer(WSGIContainer(app))
ip   = os.environ['OPENSHIFT_PYTHON_IP']
port = int(os.environ['OPENSHIFT_PYTHON_PORT'])

http_server.listen(port, ip)
IOLoop.instance().start()

现在你的应用程序将使用 Tornado web 服务器。

另见

创建你的第一个 Python 应用程序 这道菜谱
使用 Python 和 PostgreSQL 托管 Flask web 应用程序的创建与部署 这道菜谱

安装自定义 Python 包

大多数时候，你的应用程序依赖项可以通过 pip 从 PyPi 下载，但有时应用程序需要依赖于一些在 PyPi 索引中不存在的自定义库。在这道菜谱中，你将学习如何在 OpenShift Python 应用程序中使用自定义 Python 包。此菜谱的源代码可在 GitHub 上找到：github.com/OpenShift-Cookbook/chapter8-custom-package-recipe。

准备工作

本食谱基于假设你已经阅读了本章前面的食谱。要完成此食谱，你需要在机器上安装 rhc 命令行客户端。有关详细信息，请参见第一章中的安装 OpenShift rhc 命令行客户端食谱，OpenShift 入门。此外，如果你想在本地机器上运行应用程序，你需要安装 Python、pip 和 virtualenv。有关安装相应软件的链接，请参见介绍部分。

如何操作…

打开一个新的命令行终端，并运行以下命令创建一个新的 Python 2.7 应用程序：
```
$ rhc create-app myapp python-2.7
```
如果你想创建 Python 2.6 或 Python 3.3 应用程序，分别使用 Python 2.6 和 Python 3.3。
切换到myapp目录，并按如下方式删除setup.py文件：
```
$ cd myapp
$ rm –f setup.py
```
同时，创建一个.gitignore文件，以忽略虚拟环境的产物和 Python 编译文件，如下所示：
```
$ touch .gitignore
```
向其中添加以下行：
```
venv
*.pyc
```
创建一个新的虚拟环境并通过运行以下命令激活它：
```
$ virtualenv venv --python=python2.7
$ . venv/bin/activate
```
一旦激活了虚拟环境，你就可以开始安装模块，而不会影响系统的默认 Python 解释器。通过运行以下命令安装 Flask 模块：
```
$ pip install flask
```
在应用程序根目录中创建一个名为libs的新目录，如下代码所示。libs目录将用于存储你的自定义包：
```
$ mkdir libs
```
现在，我们将在libs目录中创建一个名为msgs的自定义包。要创建自定义包，请执行以下步骤：
1. 在libs目录中创建一个msgs目录。
2. 在msgs目录中创建一个名为__init__.py的空文件。
3. 在msgs目录中创建另一个名为hello.py的文件，并将以下代码放入其中：
```
def hello():
  return 'Hello World'
```
接下来，在myapp目录中创建一个名为myapp.py的新 Python 文件，并用以下代码填充它。这个简单的 Flask 应用程序将使用msgs包。看一下以下代码：
```
from flask import Flask
import msgs.hello as hello
app = Flask(__name__)
@app.route('/')
def index():
  return hello.hello()
if __name__ == '__main__':
  app.run(debug=True)
```

现在，你需要更新wsgi.py文件，以加载 Flask 应用程序，而不是 OpenShift 默认创建的应用程序。删除wsgi.py文件中的所有内容，并用以下代码替换：

#!/usr/bin/python
import os
virtenv = os.environ['OPENSHIFT_PYTHON_DIR'] + '/virtenv/'
virtualenv = os.path.join(virtenv, 'bin/activate_this.py')
try:
    execfile(virtualenv, dict(__file__=virtualenv))
except IOError:
    pass

from myapp import app as application

为了在 OpenShift 上部署此应用程序，我们必须在requirements.txt中声明所有依赖项。以下命令将把你的所有应用程序依赖项写入requirements.txt：
```
$ pip freeze > requirements.txt
```
现在，将代码提交到本地仓库，然后将更改推送到应用程序的 gear。OpenShift 将安装requirements.txt中指定的所有软件包，并通过虚拟环境使它们可用于应用程序：
```
$ git add .
$ git commit -am "application with custom package"
$ git push
```
现在，在你喜欢的浏览器中打开 Web 应用程序的 URL，查看应用程序的实际效果。你将看到浏览器中显示的Hello World文本。

它是如何工作的…

在前面的步骤中，你已经学习了如何使用 libs 目录来存储自定义包。libs 目录是 OpenShift 如何使用约定优于配置的一个示例。短语 约定优于配置 意味着，如果你遵循某些约定，就不需要编写配置代码。OpenShift 遵循一个约定，即所有在 libs 目录中的包应该放置在路径中，以便你的应用程序能够使用它们。在第 6 步中，你在 libs 目录中创建了一个名为 msgs 的自定义包，并且没有任何配置的情况下，你的应用程序可以访问这个包。

还有更多…

现在，假设你想使用 mydeps 目录来存储你的自定义包。为了使应用程序正常工作，你需要在应用程序中编写代码，将 mydeps 目录添加到系统路径中。在应用程序的 wsgi.py 文件中添加两行代码可以解决这个问题。完整的应用程序源代码可以在 GitHub 上找到，地址是 github.com/OpenShift-Cookbook/chapter8-custom-package-mydeps-recipe。看看以下代码：

import os,sys
sys.path.append(os.path.join(os.getenv("OPENSHIFT_REPO_DIR"), "mydeps"))

前两行将 mydeps 目录添加到应用程序的系统路径中。

另见

创建你的第一个 Python 应用程序 食谱
使用 Python 和 PostgreSQL 套件创建和部署 Flask web 应用程序 食谱

使用 .htaccess 文件配置 Apache

到目前为止，你应该已经意识到 OpenShift 使用 Apache 配合 mod_wsgi 来为你的 web 应用程序提供服务。在这个食谱中，你将学习如何使用 .htaccess 和 .htpasswd 文件来配置 Apache web 服务器以启用 HTTP 基本身份验证。此食谱的 GitHub 仓库是 github.com/OpenShift-Cookbook/chapter8-htaccess-recipe。

准备工作

本食谱假设你已经阅读了本章前面的食谱。为了执行本食谱，你需要在你的机器上安装 rhc 命令行客户端。有关详细信息，请参阅第一章中的 安装 OpenShift rhc 命令行客户端 食谱，使用 OpenShift 入门。

如何操作…

执行以下步骤以启用 HTTP 基本身份验证：

使用 rhc 命令行工具创建一个新的 Python 2.7 应用程序：
```
$ rhc create-app myapp python-2.7
```
切换到 myapp 目录，并在该目录下创建两个文件，.htaccess 和 .htpasswd。如果你使用的是 *nix 系统，可以使用 touch 命令。在 Windows 系统上，你可以使用文件资源管理器来创建文件。以下是相关命令：
```
$ cd myapp
$ touch .htaccess
$ touch .htpasswd
```
在 .htaccess 文件中，复制并粘贴以下代码内容：
```
AuthType Basic
AuthName "Authentication Required"
AuthUserFile "$OPENSHIFT_REPO_DIR/.htpasswd"
Require valid-user
```
将 $OPENSHIFT_REPO_DIR 替换为你的应用程序所在的 $OPENSHIFT_REPO_DIR 路径。要获取 $OPENSHIFT_REPO_DIR 的值，可以运行以下命令：
```
$ rhc ssh --command 'echo $OPENSHIFT_REPO_DIR'
```
.htpasswd 文件用于存储用户名和密码凭据。要生成新的用户名和密码，你可以使用在线生成器 www.htaccesstools.com/htpasswd-generator/。在这个方案中，用户名和密码分别是admin和password。将在线工具生成的内容放入.htpasswd文件中。我的.htpasswd文件如下所示：
```
admin:$apr1$EVxfKxv/$2BIOIAPHOZiyx4k52b5jT1ewdfg
```

提交代码，并将更改推送到应用程序配件：

$ git add .
$ git commit -am "added .htaccess and .htpasswd"
$ git push

部署应用程序后，在你最喜欢的网页浏览器中打开应用程序的 URL。这时，你将看到一个弹出窗口，要求你输入用户名和密码，如下图所示：
输入admin/password组合后，你将能够进入你的网页应用程序。

它是如何工作的…

这个方案是 OpenShift 提供给应用程序开发人员的灵活性的另一个例子。有几种方法可以配置 Apache Web 服务器。一种方法是更新主配置文件，通常名为httpd.conf。但是，OpenShift 不允许用户更新httpd.conf文件。OpenShift 允许用户通过 .htaccess 文件配置 Apache Web 服务器。.htaccess 文件提供了一种按目录进行配置更改的方法。此文件可以包含一个或多个配置指令。这些指令将应用于.htaccess文件所在的目录及其所有子目录。

在第 1 步中，你创建了一个名为myapp的 Python 2.7 应用程序。然后，在第 2 步中，你在myapp目录中创建了两个文件—.htaccess和.htpasswd。在第 3 步中，你更新了.htaccess文件的内容，添加了 HTTP 基本认证配置。你可以通过文档 httpd.apache.org/docs/2.2/howto/auth.html 了解更多内容。

接下来，在第 4 步中，你使用在线 .htpasswd 生成器生成了.htpasswd文件的内容。你将生成器生成的内容放入.htpasswd文件中，然后在第 5 步中提交了所有更改。成功部署后，在第 6 步中，你在浏览器中打开了应用程序 URL。系统要求你输入admin/password的用户名/密码凭据。输入有效的用户名/密码组合后，你就可以进入应用程序，在第 7 步中顺利登录。

另请参见

创建你的第一个 Python 应用程序 方案
使用 Python 和 PostgreSQL 托盘创建和部署 Flask Web 应用程序 方案

第九章：Node.js 开发者的 OpenShift

本章介绍了一些食谱，帮助你开始在 OpenShift 上进行 Node.js Web 应用程序开发。本章的具体食谱包括：

创建你的第一个 Node.js 应用程序
配置 Node 监控选项
管理 Node.js 应用程序的依赖
使用 use_npm 标记
为 Node.js 应用程序启用热部署
使用 Node.js 和 MongoDB Cartridge 创建和部署 Express Web 应用程序
使用 Web Socket
在 OpenShift Node.js 应用程序中使用 CoffeeScript

介绍

Node.js 是一个基于 Google Chrome V8 JavaScript 引擎的服务器端 JavaScript 平台，开发人员可以利用它编写应用程序。这些应用程序可以是 Web 应用程序、命令行工具或用于自动化任务的脚本。Node.js 是 Web 应用程序开发中的一个非常流行的选择，因为它允许 Web 开发人员在客户端和服务器端都使用相同的编程语言，例如 JavaScript。由于其异步、事件驱动、非阻塞的 I/O 特性，Node.js 非常适合构建高并发、数据密集型、实时的 Web 应用程序。Node.js 具有一个小巧的核心，提供基本的构建块 API，用于编写更高层次的框架。开发人员可以利用这些 Web 框架来构建他们的精彩 Web 应用程序。

有许多 Web 框架，如 Express（expressjs.com/）、Sails.js（sailsjs.org/）、Restify（mcavage.me/node-restify/）和 Geddy（geddyjs.org/），这些框架是 Node 社区开发的，开发人员可以用它们来构建 Web 应用程序。许多大型科技公司，如 LinkedIn、Walmart（venturebeat.com/2012/01/24/why-walmart-is-using-node-js/）和 Yahoo，都在生产应用程序中使用 Node.js。

OpenShift 为 Web 开发人员提供了一个托管平台，用于部署他们的 Node.js Web 应用程序。你可以在 OpenShift 上运行使用任何 Node.js Web 框架（如 Express 或 Geddy）构建的应用程序。写这本书时，OpenShift 支持两个版本的 Node.js——0.6 和 0.10。以下命令显示当前支持的 Node.js 版本：

$ rhc cartridges | grep node
nodejs-0.10         Node.js 0.10                            web
nodejs-0.6          Node.js 0.6                             web

注意

Node 版本 0.6 的 Cartridge 将在未来被弃用，因此建议不要在 Web 应用程序中使用它。本书将仅覆盖版本 0.10。

创建你的第一个 Node.js 应用程序 这部分将引导你创建你的第一个 OpenShift Node.js Web 应用程序。我们将了解 OpenShift 创建的模板应用程序，然后使用 Node 的 HTTP 模块编写一个简单的 HTTP 服务器，并将其部署到 OpenShift。

Node.js Web 应用程序与你可能曾经编写过的传统 Web 应用程序有很大不同。Web 应用程序本身就是 Web 服务器，因此你不需要 Apache 或任何其他 Web 服务器来托管 Web 应用程序。有多种方法可以启动 Node 应用程序，例如使用命令 node <app script file> 和 npm start，supervisor <app script file>。OpenShift 使用一个名为 node-supervisor 的 Node 模块来运行你的应用程序。node-supervisor 模块（github.com/isaacs/node-supervisor）运行 Node 应用程序并监控任何更改。一旦检测到更改，它会重新启动应用程序。在配置 Node 监督程序选项的教程中，你将学习如何自定义一些监督程序选项，以利用热重载行为。使用监督程序的替代方法是使用 npm start 命令运行 Node 应用程序。你可以通过使用标记文件配置 OpenShift Node.js 应用程序，使用 npm start 而不是 supervisor。这一点将在使用 use_npm 标记的教程中讲解。

在管理 Node.js 应用程序依赖的教程中，你将学习 OpenShift 如何使用 npm 来安装和管理应用程序依赖。

本章中的示例应用程序将使用 Express Web 框架和 MongoDB 数据库进行开发。使用 Node.js 和 MongoDB 卡片创建和部署 Express Web 应用程序的教程将引导你完成在 OpenShift 上构建和部署 Express Web 应用程序所需的所有步骤。本章的所有源代码都可以在 OpenShift Cookbook GitHub 组织中找到（github.com/OpenShift-Cookbook）。

Node.js 在构建实时 Web 应用程序方面非常流行，特别是使用 Web Sockets。在使用 Web Sockets的教程中，你将使用 Node 的 Socket.IO 库构建一个简单的实时应用程序。

开发人员除了使用 JavaScript 编写 Node 应用程序外，还可以使用 CoffeeScript 编写 Node 应用程序。CoffeeScript 会编译成 JavaScript，且在不喜欢使用 JavaScript 的开发人员中非常流行。在 OpenShift Node.js 应用程序中使用 CoffeeScript的教程将详细介绍这一点。

要在本地机器上运行本章中开发的示例应用程序，你需要在操作系统上安装 Node。你可以从官方网页获取适用于你操作系统的最新 Node.js 安装程序，nodejs.org/download/。安装程序还会为你安装 npm。本章还将使用 MongoDB 数据库。你可以从其官方网站获取适用于你操作系统的最新 MongoDB 安装程序（www.mongodb.org/downloads）。

本章假设你已经掌握了 Node Web 开发基础、OpenShift 应用程序基础以及如何使用 OpenShift 数据库 Cartridge。如果你不熟悉这些主题，我建议你先阅读第三章，创建与管理应用程序，以及第六章，在 OpenShift 应用程序中使用 MongoDB 和第三方数据库 Cartridge，然后再继续本章内容。

创建你的第一个 Node.js 应用程序

在这个配方中，你将学习如何使用 rhc 命令行工具创建你的第一个 OpenShift Node.js 应用程序。在了解了 OpenShift 创建的模板应用程序后，你将使用 Node 的 HTTP 模块编写一个 Hello World Node.js 应用程序。

准备工作

要完成这个配方，你需要在你的机器上安装 rhc 命令行客户端。详情请参考第一章中安装 OpenShift rhc 命令行客户端的配方，OpenShift 入门。此应用程序将消耗一个 gear，因此，如果你没有额外的 gear 可用于这个配方，请使用rhc delete-app <app_name> --confirm命令删除现有应用程序。要在本地机器上运行此应用程序，你需要在机器上安装 Node。你可以从官方网站获取适用于你操作系统的最新 Node.js 安装程序，网址是nodejs.org/download/。

如何执行…

执行以下步骤来创建你的第一个 OpenShift Node.js 应用程序：

打开一个新的命令行终端，并将目录更改为你想创建应用程序的合适位置。要创建一个 Node.js 0.10 应用程序，请运行以下命令：
```
$ rhc create-app myapp nodejs-0.10
```
打开你最喜欢的 web 浏览器，访问 http://myapp-{domain-name}.rhcloud.com 查看应用程序。请将 {domain-name} 替换为你的 OpenShift 账户域名。
OpenShift 创建的模板应用程序是一个 Express Web 框架应用程序。你可以通过使用 --from-code 选项指定自己的公共 Git 仓库来使用你自己的模板应用程序。这在第三章的指定自己的模板 Git 仓库 URL配方中已介绍，创建与管理应用程序。在这个配方中，你不需要 OpenShift 生成的模板代码，所以请删除 OpenShift 创建的所有文件和目录，除了 .openshift 目录。在 *nix 系统上，你可以使用 rm 命令删除文件，如下所示。Windows 系统上，你可以使用文件资源管理器或命令行等效命令删除这些文件。
```
$ cd myapp
$ rm -rf deplist.txt index.html node_modules/ package.json server.js
```

在应用程序根目录中创建一个名为 server.js 的新空文件。在 *nix 系统中，你可以使用 touch 命令创建一个新文件。在 Windows 系统中，你可以使用文件资源管理器创建新文件。运行以下命令：

$ touch server.js

在你喜欢的编辑器中打开文件，并使用以下代码填充它：

var http = require('http');
var ip = process.env.OPENSHIFT_NODEJS_IP || '127.0.0.1';
var port = process.env.OPENSHIFT_NODEJS_PORT || 3000;
var server = http.createServer(function(req,res){
   res.writeHead(200, {'Content-Type':'text/plain'});
   res.end('Hello World!!');
});
server.listen(port,ip);
console.log('Server running at http://%s:%d',ip,port);

要在本地计算机上运行应用程序，请运行以下命令：
```
$ node server.js
```
要查看应用程序的实际效果，请在你喜欢的浏览器中打开 http://127.0.0.1:3000。你将在浏览器中看到呈现的 Hello World!! 消息。
要将应用程序部署到 OpenShift，请将代码提交到本地 Git 仓库，然后将更改推送到应用程序齿轮：
```
$ git add .
$ git commit -am "Hello World Node.js application" 
$ git push
```
部署成功后，在你喜欢的浏览器中打开 http://myapp-{domain-name}.rhcloud.com。浏览器将呈现 Hello World!!。

工作原理如下…

在前面的步骤中，你从头开始创建了一个 Hello World Node.js 应用程序，并将其部署到 OpenShift 上。在上述步骤中编写的 Hello World 应用程序与如果要在本地计算机或其他地方运行此应用程序时将要编写的应用程序没有任何不同。除了环境变量外，没有 OpenShift 特定的内容。

在第一步中，你使用了 rhc 命令行工具创建了一个 OpenShift Node.js 0.10 应用程序。 rhc create-app 命令将向 OpenShift 代理发送 HTTP POST 请求。 OpenShift 代理将接受请求，然后启动应用程序创建过程。你指定 OpenShift 应该创建一个名为 myapp 的 Node.js 0.10 应用程序。 OpenShift 将使用这些细节以及一些默认设置来创建 myapp 应用程序。默认设置包括小型齿轮大小，不可扩展应用程序，并使用当前目录克隆 Git 仓库。在幕后，OpenShift 完成了以下操作：

OpenShift 创建了一个带有 Node.js 载体的新应用程序齿轮。
它为你的应用程序创建了一个私有 Git 仓库，并使用模板应用程序填充了它。 OpenShift 创建的模板应用程序是一个 Express Web 框架应用程序。
它安装了一个 Git 操作钩子，用于构建应用程序。在应用程序构建阶段，它将使用 npm install 命令下载 package.json 中提到的所有依赖项。
它为你的应用程序创建了一个公共 DNS，以便从外部世界访问。

成功创建应用程序后，你将在当前目录中拥有 myapp 目录。你可以按照第 2 步中提到的在浏览器中打开应用程序 URL 的方式查看应用程序。应用程序创建过程在第三章的 使用 rhc 命令行客户端创建 OpenShift 应用程序 配方中详细说明了。

现在，让我们来看看 OpenShift 创建的模板应用程序：

$ cd myapp && ls -ap
.git/      README.md    index.html   package.json
.openshift/   deplist.txt   node_modules/   server.js

模板应用有五个文件——README.md、index.html、package.json、deplist.txt 和 server.js——以及 node_modules 目录，除此之外还有 .openshift 和 .git 目录。我们已经在 使用 rhc 命令行客户端创建 OpenShift 应用 这一食谱中讲解了 .openshift 和 .git，可以参考第三章，创建和管理应用，所以这里不再赘述。接下来我们逐一讲解其他文件：

README.md：这是一个标准的 Git 仓库 Markdown 文件，用于总结你的项目。GitHub 使用 README.md 来生成项目的 HTML 概述。
index.html：此文件包含当你在浏览器中查看应用时看到的 HTML 标记。它是一个 HTML 5 文件，使用了 Twitter Bootstrap 样式。
package.json：这是你的 Node 应用描述文件。它是一个 JSON 文档，包含关于应用的所有信息，例如名称、描述、版本和应用所依赖的库。完整的文档可以在 www.npmjs.org/doc/json.html 查阅。
deplists.txt：这是 OpenShift Node.js 应用中用于指定应用依赖的过时方法。建议不要使用它，因为未来可能会删除此方法。该文件仅存在于向后兼容的情况下，以便使用它的应用继续运行。
server.js：此文件包含由 OpenShift 创建的模板 Express Web 框架应用。该应用暴露了两个路由，/ 和 /asciimo。/ 路由呈现 index.html，第二个路由呈现带有图像的 HTML 页面。Express 应用将在 使用 Node.js 和 MongoDB 插件创建和部署 Express Web 应用 这一食谱中详细介绍，因此我们在本食谱中不再讲解。
node_modules：此目录包含你在 package.json 中指定的所有应用依赖项。npm install 命令会将所有依赖项下载到 node_modules 目录中。

OpenShift 生成的模板应用是一个标准的 Express Web 应用。要在本地机器上运行此应用，你可以运行以下命令：

$ npm install
$ node server.js

该应用将在 http://127.0.0.1:8080/ 运行。前两个命令执行了以下操作：

npm install 命令会下载 package.json 文件中列出的所有依赖项。模板应用提到将 express 作为其依赖项，因此 npm install 命令将下载 Express 及其所有传递性依赖项，并将其存放在 node_modules 目录中。
如介绍部分所述，在 Node 中，服务器和应用是同一个。因此，你使用 node server.js 命令启动了应用的服务器。这个命令启动了 HTTP 服务器，你可以开始发起请求。

node server.js 命令是一种启动应用程序的方式。启动应用程序的其他替代方式是 npm start 和 supervisor server.js 命令。如果提供了启动脚本，npm start 命令将运行该脚本。启动脚本可以在 package.json 文件中指定：

"scripts":{"start":"node server.js"}

如果 package.json 文件中没有包含启动脚本，npm start 命令将默认使用 node server.js 命令作为启动脚本。

默认情况下，OpenShift 不使用 npm start 或 node <server script> 命令来运行应用程序。它使用一个名为 node-supervisor 的模块来运行应用程序。你可以配置 OpenShift 的 Node 应用程序使用 npm start 命令，而不是 node-supervisor。这将在 使用 use_npm 标记 这一部分中进行讲解。使用 supervisor 的主要优势是，当应用程序崩溃时，它可以重启应用程序。此外，你还可以使用 supervisor 实现热重载功能。它可以监视一组目录和文件，并在代码发生变化时重新启动应用程序。

如果你想在本地机器上使用 node-supervisor，你可以使用以下命令安装 node-supervisor 模块：

$ npm install supervisor -g

现在你可以使用 supervisor server.js 命令启动应用程序。每当你对源代码进行更改时，这将重新启动应用程序。这在开发过程中非常有用，因为它节省了重新启动应用程序所需的时间。

在第 3 步中，你删除了 OpenShift 生成的模板源代码，以便从头开始编写一个简单的 HTTP 服务器。在第 4 步中，你创建了一个名为 server.js 的新文件，并用 Hello World 的 Node.js 代码填充了它。第 4 步中的代码执行以下操作：

你通过 require() 函数导入了 Node HTTP 模块。这个模块将用于编写服务器。
然后，你创建了两个变量来保存 IP 地址和端口。如果应用程序运行在本地机器上，OpenShift 特定的环境变量将不可用。因此，IP 和端口将分别设置为 127.0.0.1 和 3000。
接下来，你使用 HTTP 模块的 createServer() 函数创建了 HTTP 服务器。你传递了一个回调函数，该函数将在每次请求发生时被触发。回调函数接受两个参数——请求和响应，并将 Hello World 写入响应中。
最后，你指示服务器监听 IP 和端口变量。

在第 5 步中，你通过运行 node server.js 命令在本地机器上测试了 Hello World 应用程序。为了将应用程序部署到 OpenShift，你将代码提交到本地 Git 仓库，并在第 6 步中将更改推送到应用程序的 gear。

当你将源代码推送到 OpenShift Node.js 应用程序的 Git 仓库时，OpenShift 将执行以下操作：

首先，所有的代码都被推送到应用程序的 Git 仓库。
然后，如果 package.json 文件存在，并且这是你第一次推送源代码，OpenShift 会下载 package.json 中提到的所有依赖项。每次后续推送时，只有尚未存在的新增依赖项会被下载，所有现有的节点模块将被缓存。
OpenShift 将使用后续列表中提到的三种命令之一来运行应用。当 use_npm 标记文件存在时，运行方式会有所变化，具体内容将在 使用 use_npm 标记 方案中介绍。
- 如果 package.json 不存在，OpenShift 将运行 supervisor server.js 命令。
- 如果 package.json 存在且应用的主文件名是 server.js，OpenShift 将运行 supervisor server.js 命令。主文件名在 package.json 的 main 元素中指定。
- 如果 package.json 存在且应用的主文件名不是 server.js（例如 app.js），OpenShift 将运行 supervisor app.js 命令。

由于你未包含 package.json，OpenShift 将使用 supervisor server.js 命令来运行应用。应用启动后，你可以在浏览器中打开应用的 URL，你将看到 HelloWorld!!，如第 7 步所示。

另见

配置节点监督员选项 方案
为 Node.js 应用启用热部署 方案
管理 Node.js 应用依赖 方案

配置节点监督员选项

如 创建你的第一个 Node.js 应用 方案中所述，OpenShift 使用 node-supervisor 模块来运行你的程序。在本方案中，你将学习如何配置 node-supervisor 选项。如果你在机器上已安装 node-supervisor 模块，可以通过运行以下命令查看所有支持的选项。你可以通过执行 npm install supervisor -g 命令来安装 node-supervisor。帮助选项可以通过以下命令查看：

$ supervisor --help

OpenShift 允许你配置 node-supervisor 的 watch 和 poll-interval 选项。watch 选项允许你指定一个以逗号分隔的文件夹或 JavaScript 文件列表，监督员将监视这些文件的变化。poll-interval 选项允许你指定监督员检查变化的频率。

准备工作

要完成此步骤，你需要在机器上安装 rhc 命令行客户端。请参考第一章，OpenShift 入门中的安装 OpenShift rhc 命令行客户端步骤获取详细信息。此应用程序将消耗一个 gear，因此如果你没有额外的 gear 可用，可以使用rhc delete app <app_name> --confirm命令删除现有应用程序。要在本地机器上运行此应用程序，你需要安装 Node。你可以从官方网站nodejs.org/download/获取适合你操作系统的最新 Node.js 安装程序。

如何操作……

执行以下步骤以配置监视器选项：

如果你还没有运行 Node.js 应用程序，可以执行以下命令创建一个新应用程序。这将创建你在创建你的第一个 Node.js 应用程序步骤中创建的应用程序。
```
$ rhc create-app myapp nodejs-0.10 --from-code https://github.com/OpenShift-Cookbook/chapter9-recipe1.git
```
切换到myapp目录，并创建两个环境变量来配置监视器的轮询间隔和需要监视的目录。
```
$ cd myapp
$ rhc env-set OPENSHIFT_NODEJS_POLL_INTERVAL=60000 OPENSHIFT_NODEJS_WATCH=$OPENSHIFT_REPO_DIR --app myapp
```
将$OPENSHIFT_REPO_DIR变量替换为你的应用程序的$OPENSHIFT_REPO_DIR环境变量的值。你可以通过运行以下命令获取$OPENSHIFT_REPO_DIR的值：
```
$ rhc ssh --command "env |grep OPENSHIFT_REPO_DIR"
```
重启应用程序，以便它能够识别新的环境变量：
```
$ rhc restart-app --app myapp
```

工作原理……

node-supervisor 模块帮助 OpenShift 在 Node 应用程序崩溃时自动重启应用程序。这对开发人员非常有用，因为如果应用程序可以在重启后恢复，开发人员就不必手动重启应用程序。node-supervisor 的另一个有用特性是它支持热重载。你可以告诉 node-supervisor 监视某些目录或文件，当这些文件发生变化时，应用程序会被重启，从而实现热重载行为。

在步骤 2 中，你创建了两个环境变量，OpenShift 会暴露这些环境变量来配置热重载行为。OPENSHIFT_NODEJS_WATCH环境变量允许你指定一个用逗号分隔的文件夹或 JavaScript 文件列表，监视器应监视这些文件的变化。你告诉监视器监视$OPENSHIFT_REPO_DIR变量。OPENSHIFT_NODEJS_POLL_INTERVAL环境变量允许你指定以毫秒为单位的轮询频率，监视器应多长时间检查一次变化。轮询的默认值是 10 秒。你告诉监视器每 60 秒轮询一次$OPENSHIFT_REPO_DIR。

node-supervisor 热重载行为不适用于git push部署模型，但如果你使用 OpenShift 的 SFTP 支持（www.openshift.com/blogs/getting-started-with-sftp-and-openshift），它会很有用。它不适用于git push部署模型的原因是，你已经将代码推送到应用程序环境中，这会更新$OPENSHIFT_REPO_DIR变量并重启应用程序。与git push一起使用热部署的首选方式是使用hot_deploy标记文件。这在为 Node.js 应用程序启用热部署食谱中有解释。为了看到热重载的实际效果，我们将通过 SSH 连接到应用程序环境并按如下方式修改源代码：

使用rhc ssh命令 SSH 连接到 OpenShift 应用程序环境。除了 SSH，你还可以使用 SFTP 客户端连接到应用程序环境，如以下博客所述：www.openshift.com/blogs/using-filezilla-and-sftp-on-windows-with-openshift。
一旦连接成功，切换到app-root/repo目录：
```
$ cd app-root/repo
```
使用vim打开server.js文件，将"Hello World!!"更改为"Hello OpenShift User!!"，然后保存文件。
在下一个轮询周期中，supervisor 将检测到变化并重启应用程序。你可以通过在你喜欢的浏览器中打开应用程序 URL 来查看你的更改。

另见

创建你的第一个 Node.js 应用程序食谱
为 Node.js 应用程序启用热部署食谱
管理 Node.js 应用程序依赖食谱

管理 Node.js 应用程序依赖

到目前为止，在本章中，你不需要使用任何第三方库。你开发的应用程序是简单的Hello World应用程序，不需要任何第三方库就能完成工作。在实际应用中，你需要使用别人编写的库。Node.js 使得开发人员通过 npm 非常容易地使用第三方库。npm 是 Node.js 的包管理器，随 Node.js 一起捆绑提供。它是一个命令行工具，允许你发布新模块、从 npm 注册表中下载现有模块，并安装第三方模块。在这个食谱中，你将编写另一个简单的应用程序，但它将使用 Express 框架。这个食谱的目标是让你了解 Node.js 的依赖管理，而不被应用程序的细节所困扰。

准备就绪

要完成此配方，你需要在你的机器上安装 rhc 命令行客户端。有关详细信息，请参阅第一章中的 安装 OpenShift rhc 命令行客户端 配方， 开始使用 OpenShift。此应用程序将消耗一个 gear，因此，如果你没有额外的 gear 可用于此配方，请使用 rhc delete app <app_name> --confirm 命令删除现有的应用程序。要在本地机器上运行此应用程序，你需要在机器上安装 Node。你可以从官方网页获取适用于你的操作系统的 Node.js 最新安装程序（nodejs.org/download/）。

如何实现……

在这个配方中，你将从零开始创建一个 Hello World Express 框架 Web 应用程序。请执行以下步骤来创建该应用程序：

通过执行以下命令重新创建在 创建你的第一个 Node.js 应用程序 配方中创建的应用程序：
```
$ rhc app create myapp nodejs-0.10 --from-code https://github.com/OpenShift-Cookbook/chapter9-recipe1.git
```
在应用程序根目录下创建一个名为 package.json 的新文件。package.json 文件是一个应用程序描述文件，你可以用它来定义应用程序的元数据及其依赖项。
```
{
  "name": "myapp",
  "description": "My OpenShift Node.js Application",
  "version": "0.0.1"
}
```
该应用程序将使用 Express Web 框架，因此使用以下命令安装 express 依赖项：
```
$ npm install express --save
```
这将下载 Express 框架模块及其依赖项到 node_modules 目录，并在 package.json 文件中添加 express 依赖项，如下所示的代码：
```
{
  "name": "myapp",
  "description": "My OpenShift Node.js Application",
  "version": "0.0.1",
  "dependencies": {
    "express": "~4.3.1"
  }
}
```

将 server.js 中的代码替换为以下代码：

var express = require('express');
var ip = process.env.OPENSHIFT_NODEJS_IP || '127.0.0.1';
var port = process.env.OPENSHIFT_NODEJS_PORT || 3000;
var app = express();
app.get('/',function(req,res){
   res.send('Hello World!!');
});
app.listen(port,ip);
console.log('Server running at http://%s:%d',ip,port);

将 node_modules 目录添加到 .gitignore 文件中。我们将 node_modules 目录添加到 .gitignore 中，以允许 OpenShift 使用 npm 下载所有依赖项。如果你不将 node_modules 添加到 .gitignore，OpenShift 将不会下载依赖项，而是使用你 node_modules 目录中的依赖项：
```
$ echo "node_modules/" > .gitignore
```
提交代码，并将更改推送到应用程序 gear：
```
$ git add .
$ git commit -am "used express"
$ git push
```
在应用程序成功构建并部署后，你将看到应用程序在 http://myapp-{domain-name}.rhcloud.comhttp://myapp-{domain-name}.rhcloud.com 上运行。

它是如何工作的……

server.js command:

remote: npm http GET https://registry.npmjs.org/express
remote: npm http 200 https://registry.npmjs.org/express
remote: npm info retry fetch attempt 1 at 12:45:38
remote: npm http GET https://registry.npmjs.org/express/-/express-4.3.1.tgz
remote: npm http 200 https://registry.npmjs.org/express/-/express-4.3.1.tgz
…

还有更多……

在创建你的第一个 Node.js 应用程序配方中，我提到过，当你将更改推送到 OpenShift 应用程序的 gear 时，OpenShift 会检查是否存在 package.json 文件。如果 package.json 文件存在，OpenShift 会使用 main 字段的值作为应用程序的主要入口点。由于你没有在 package.json 中定义 main 字段，OpenShift 将默认使用 server.js 作为入口点。假设你将 server.js 重命名为 app.js，那么为了在 OpenShift 上运行，你需要为 main 字段创建一个条目，如下所示的代码片段所示：

{
  "name": "myapp",
  "description": "My OpenShift Node.js Application",
  "version": "0.0.1",
  "dependencies": {
    "express": "~4.3.1"
  },
  "main":"app.js"
}

另见

创建你的第一个 Node.js 应用程序 配方
使用 use_npm 标记 配方

使用 use_npm 标记

OpenShift 使用 node-supervisor 模块来运行你的 Node 应用程序，但你也可以告诉 OpenShift 使用 npm start 命令来运行该应用程序。在本教程中，你将学习如何实现这一点。

准备工作

要完成本教程，你需要在你的计算机上安装 rhc 命令行客户端。有关详细信息，请参阅第一章中的 安装 OpenShift rhc 命令行客户端 部分，OpenShift 入门。此应用程序将消耗一个 gear，如果你没有额外的 gear 可以用于本教程，可以使用 rhc delete app <app_name> --confirm 命令删除现有的应用程序。为了在本地机器上运行此应用程序，你需要在你的计算机上安装 Node。你可以从 Node.js 官方网站（nodejs.org/download/）获取适合你操作系统的最新安装程序。

如何操作…

执行以下步骤，使用 npm start 命令来运行你的应用程序：

打开一个新的命令行终端，重新创建你在 管理 Node.js 应用程序依赖 部分中创建的应用程序，操作如下：
```
$ rhc create-app myapp nodejs-0.10 --from-code https://github.com/OpenShift-Cookbook/chapter9-recipe3.git
```
在 .openshift/markers 目录中创建一个名为 use_npm 的标记文件。在 *nix 系统中，你可以使用如下代码的 touch 命令。在 Windows 系统中，你可以使用文件资源管理器创建一个空文件。
```
$ cd myapp
$ touch .openshift/markers/use_npm
```

提交代码并推送更改到应用程序的 gear：

$ git add .
$ git commit -am "using use_npm marker"
$ git push

git push 的日志中会清楚地提到应用程序是通过 npm start 命令启动的：

remote: *** NodeJS supervisor is disabled due to .openshift/markers/use_npm
remote: *** Starting application using: npm start -d

工作原理…

在第 1 步中，你创建了一个 Express 框架的 Web 应用程序，这是我们在 管理 Node.js 应用程序依赖 部分中创建的应用程序。该应用程序只有两个文件——server.js 和 package.json。server.js 文件包含应用程序的源代码，package.json 包含应用程序的元数据和依赖项。

然后，在第 2 步中，你创建了一个标记文件 use_npm。use_npm 标记文件的存在告诉 OpenShift 你希望使用 npm start 命令来运行该应用程序，而不是使用 node-supervisor 模块。npm start 命令为开发者提供了更多的灵活性来运行他们的应用程序。它允许开发者在 package.json 中指定自己的启动脚本，OpenShift 会使用这个脚本来运行应用程序。package.json 如下所示：

{
  "name": "myapp",
  "description": "My OpenShift Node.js Application",
  "version": "0.0.1",
  "dependencies": {
    "express": "~4.3.1"
  }
}

正如你在上面的清单中所看到的，它没有提到任何启动脚本。当 package.json 文件中没有启动脚本时，OpenShift 会回退到使用 node server.js 作为启动脚本：

"scripts": {"start": "node server.js"}

这就是为什么在第 4 步中，执行 git push 后应用程序能够成功启动的原因。

现在假设你想将 server.js 重命名为 app.js。如果你现在提交源代码并推送更改，应用程序将无法启动。你将在 git push 的日志中看到以下信息：

remote: *** NodeJS supervisor is disabled due to .openshift/markers/use_npm
remote: *** Starting application using: npm start -d
remote: Application 'myapp' failed to start 1

要使此应用程序重新运行，你必须指定如下的启动脚本：

{
  "name": "myapp",
  "description": "My OpenShift Node.js Application",
  "version": "0.0.1",
  "dependencies": {
    "express": "~4.3.1"
  },
"scripts":{"start":"node app.js"}
}

另见

使用 Node.js 和 MongoDB 模块创建并部署 Express Web 应用程序教程
管理 Node.js 应用依赖教程

启用 Node.js 应用的热部署

在本教程中，你将学习如何为 Node.js 应用启用热部署。

如何做…

执行以下步骤以启用应用的热部署：

使用前一个教程中开发的源代码创建一个新的 Node.js 应用程序：

$ rhc app create myapp nodejs-0.10 --from-code https://github.com/OpenShift-Cookbook/chapter9-recipe3.git

要启用热部署，请在 .openshift/markers 目录下创建一个名为 hot_deploy 的空文件。这个文件被称为标记文件，因为它不包含任何内容。在 *nix 系统中，你可以使用 touch 命令来创建该文件。在 Windows 中，你可以通过文件资源管理器创建一个新文件。如果你不在 myapp 目录下，首先切换到 myapp 目录。请查看以下命令：
```
$ cd myapp
$ touch .openshift/markers/hot_deploy
```
将文件添加到 Git 索引，提交到本地 Git 仓库，然后通过输入如下命令将更改推送到应用环境：
```
$ git commit -am "enabled hot deployment"
$git push
```
在 git push 日志中，你将看到一条消息，表明由于启用了热部署，模块未被停止：
```
remote: Not stopping cartridge node.js because hot deploy is enabled
```

它是如何工作的…

每次你做出更改并推送到 OpenShift 应用环境时，OpenShift 首先会停止你的环境（即所有模块），将应用程序 Git 仓库中的源代码复制到app-root/runtime/repo，执行构建，准备好工件，最后启动环境（即所有模块）。这个过程需要一些时间，并不适合快速开发和部署。为了支持快速开发和更快的部署，OpenShift 支持热部署。热部署意味着你可以在不需要重启所有应用模块的情况下部署你的更改。

hot_deploy 标记文件的存在告知 OpenShift 你希望执行热部署。在停止并启动应用模块之前，OpenShift 会检查 hot_deploy 标记文件是否存在。如果该标记文件存在，OpenShift 将不会停止模块，并且更改会在不重启模块的情况下部署。热部署非常适合开发，我建议你在开发过程中始终使用它。

注意

如果你启用了热部署并设置了新的环境变量，或安装了新的模块，你必须重新启动应用程序以便服务器能够识别新的环境变量。

另见

使用 Node.js 和 MongoDB 模块创建并部署 Express Web 应用程序教程
配置 Node supervisor 选项教程

使用 Node.js 和 MongoDB 模块创建并部署 Express Web 应用程序

在这个教程中，你将从零开始构建一个 Node.js 应用程序，使用 Express Web 框架和 MongoDB。我选择了 Express，因为它非常易于使用，并且是 Node 社区中流行的 Web 框架。你也可以在 OpenShift 上运行其他任何 Web 框架，比如 Geddy。

你将开发一个职位存储应用程序，允许用户为公司发布职位空缺。该应用将是一个单页 Web 应用（en.wikipedia.org/wiki/Single-page_application），使用 Backbone.js 前端（backbonejs.org/）构建。该应用可以执行以下操作：

当用户访问应用的 / URL 时，用户将看到存储在 MongoDB 数据库中的公司列表。在后台，基于 Backbone.js 的前端将发起一个 REST HTTP GET 请求 ('/api/v1/companies') 来获取所有的公司：
用户可以通过访问 http://jobstore-{domain-name}.rhcloud.com/#companies/new 或点击 + 图标来创建新公司。这将呈现一个表单，用户可以在其中输入新公司详细信息，如下图所示。当用户提交表单时，基于 Backbone.js 的前端将向 REST 后端发起一个 HTTP POST 请求，并将与公司相关的数据存储在 MongoDB 中：
当用户点击任何一家公司时，他们将看到该公司职位空缺的列表。在后台，基于 Backbone.js 的前端将发起一个 HTTP GET 请求 ('/api/v1/companies/company_id/jobs') 来获取所选公司所有可用的职位，使用其 ID。请查看以下截图：
用户可以通过点击 New Job 链接来发布公司的新职位。这将呈现一个网页表单，用户可以在其中输入职位的详细信息。基于 Backbone.js 的前端将向 REST 后端发起一个 HTTP POST 请求，并将与职位相关的数据存储在 MongoDB 数据库中：

该应用的源代码可以在 GitHub 上找到，地址为 github.com/OpenShift-Cookbook/chapter9-jobstore-nodejs-express。

准备工作

为了完成本指南，你需要在机器上安装 rhc 命令行客户端。有关详细信息，请参考第一章中的安装 OpenShift rhc 命令行客户端部分。此应用程序将消耗一个 gear，因此如果你没有额外的 gear 来进行此指南，请使用rhc delete app <app_name> --confirm命令删除现有应用程序。要在本地机器上运行此应用程序，你需要在机器上安装 Node 和 MongoDB。你可以从其官方网站获取适用于你操作系统的 Node.js 最新安装程序（nodejs.org/download/）。你可以从 MongoDB 官方网站获取适用于你操作系统的最新安装程序（www.mongodb.org/downloads）。

如何进行操作…

打开一个新的命令行终端，导航到你希望创建应用程序的合适位置。运行如下命令以创建 jobstore 应用程序：
```
$ rhc create-app jobstore nodejs-0.10 mongodb-2.4
```
此命令将创建一个名为jobstore的应用程序，该应用程序使用 Node.js 和 MongoDB 组件。
由于该应用程序将从零开始构建，我们将删除 OpenShift 生成的模板源代码。将目录更改为jobstore，并使用rm命令删除以下文件和目录（适用于*nix 机器）。在 Windows 上，你可以使用文件资源管理器删除文件和目录。
```
$ cd jobstore
$ rm -rf deplist.txt index.html node_modules/ package.json server.js
```
通过执行以下命令将node_modules目录添加到.gitignore文件中：
```
$ echo "node_modules/" > .gitignore
```
Express 团队提供了一个项目生成器，你可以用它来创建一个 Express 模板应用程序。该生成器将使用最新的 Express 版本（即 4.2.0）创建一个应用程序框架。它使开发者能够轻松开始 Express 应用程序的开发。你可以通过运行以下命令全局安装express-generator包：
```
$ npm install -g express-generator
```
注意

请确保安装 express-generator 4.2.0 或更高版本。此指南是基于 express-generator 4.2.0 编写的。你可以通过输入express --version命令来检查版本。
一旦生成器全局安装完成，你可以使用express命令行工具在机器上的任何位置生成项目。请确保你位于jobstore目录，并通过运行以下命令创建项目：
```
$ express --ejs . --force
```
要在本地机器上运行此应用程序，首先需要使用 npm 安装所有依赖项：
```
$ npm install
```
现在，运行应用程序，请使用以下命令：
```
$ DEBUG=jobstore ./bin/www
```
你可以通过访问http://127.0.0.1:3000/在你喜欢的浏览器中查看应用程序。生成的应用程序公开了app.js中指定的两个路由：
```
app.use('/', routes);
app.use('/users', users);
```
当用户发出对/的 GET 请求时，routes回调会被触发。routes回调定义在routes/index.js中。该回调渲染index.ejs视图。

当用户向 /users 发起 HTTP GET 请求时，将调用 users 回调函数。默认实现只会在响应体中写入 respond with a resource。
在我们的单页面 web 应用中，当用户向应用根 URL 发起 HTTP GET 请求时，将渲染基于 Backbone.js 的前端。将 index.ejs 的内容替换为项目 GitHub 仓库中的 index.js，链接为 github.com/OpenShift-Cookbook/chapter9-jobstore-nodejs-express/blob/master/views/index.ejs。此外，还需从应用的 GitHub 仓库 github.com/OpenShift-Cookbook/chapter9-jobstore-nodejs-express 中复制 css (github.com/OpenShift-Cookbook/chapter9-jobstore-nodejs-express/tree/master/public/css) 和 js (github.com/OpenShift-Cookbook/chapter9-jobstore-nodejs-express/tree/master/public/js) 目录，并将它们放入公共目录中。

重启应用程序后，你将看到索引路由正在运行。这一次，它将渲染应用程序的用户界面。
该应用不再需要 routes 目录中的 users.js 文件，因此将其删除。删除 routes/users.js 后，还需在 app.js 文件中移除其引用。你需要从 app.js 文件中删除以下两行：
```
var users = require('./routes/users');
app.use('/users', users);
```
在 routes 目录下创建一个名为 api.js 的新文件。该文件将包含我们应用的 REST 后端。在 *nix 系统中，你可以使用 touch 命令创建新文件。在 Windows 系统中，可以通过文件资源管理器创建该文件。
```
$ touch routes/api.js
```
该应用将使用 MongoDB 数据库存储数据。为了与 MongoDB 交互，你需要使用一个第三方库。对于这个应用，你将使用 mongojs 模块。使用以下 npm 命令安装该模块：
```
$ npm install mongojs --save
```

下一步是配置 MongoDB 数据库，以便我们的 REST API 可以与 MongoDB 进行交互。在 api.js 文件中放入以下代码：

var db_name = process.env.OPENSHIFT_APP_NAME || "jobstore";
var connection_string = '127.0.0.1:27017/' + db_name;
// if OPENSHIFT env variables are present, use the available connection info:
if (process.env.OPENSHIFT_MONGODB_DB_PASSWORD) {
    connection_string = process.env.OPENSHIFT_MONGODB_DB_USERNAME + ":" +
        process.env.OPENSHIFT_MONGODB_DB_PASSWORD + "@" +
        process.env.OPENSHIFT_MONGODB_DB_HOST + ':' +
        process.env.OPENSHIFT_MONGODB_DB_PORT + '/' +
        process.env.OPENSHIFT_APP_NAME;
}
var mongojs = require("mongojs");
var db = mongojs(connection_string, ['jobstore']);
var companies = db.collection("companies");

正如本食谱介绍中提到的，有两个与公司相关的操作——获取所有公司和将公司存储到 MongoDB 数据库中。这些操作将作为两个路由暴露在 app.js 文件中，如下所示：

var api = require('./routes/api');
app.get('/api/v1/companies', api.companies);
app.post('/api/v1/companies', api.saveCompany);

当向 /api/v1/companies 发起 HTTP GET 请求时，将调用 api.companies 回调函数。api.companies 回调在 api.js 路由文件中定义。该回调将在 companies 集合上执行 find 操作，查找 MongoDB 数据库中所有公司并将其写入响应对象。请看以下命令：

exports.companies = function (req, res, next) {
    companies.find().sort({registeredAt: -1}, function (err, companies) {
        if (err) {
            return next(err);
        }
        return res.json(companies);
    });
};

类似地，当 HTTP POST 请求发送到 /api/v1/companies URL 时，api.saveCompany 回调函数将被调用。api.saveCompany 回调在 api.js 路由文件中定义。该回调将从请求对象中创建一个 company 对象，并将其持久化到 MongoDB 数据库中：

exports.saveCompany = function (req, res, next) {
    var company = {
        "name": req.body.name,
        "description": req.body.description,
        "registeredAt": new Date(),
        "contactEmail": req.body.contactEmail,
        "jobs": []
    };
    companies.save(company, function (err, saved) {
        if (err) {
            return next(err);
        }
        console.log(saved);
        res.json(saved);
    })
};

接下来，你将编写 REST 端点来存储和列出作业数据。有两个与作业相关的 REST 端点——列出某公司所有作业和保存某公司作业。这些将作为两个路由暴露在 app.js 中。请看下面的代码：

app.get('/api/v1/companies/:companyId/jobs', api.jobsForCompany);
app.post('/api/v1/companies/:companyId/jobs', api.postJobForCompany);

当 HTTP GET 请求发送到 /api/v1/companies/:companyId/jobs 时，jobsForCompany 回调函数将被调用。此回调将查找与 companyId 对应的公司，然后返回嵌入在数组中的作业：

exports.jobsForCompany = function (req, res, next) {
    var companyId = req.param('companyId');
    companies.findOne({"_id": mongojs.ObjectId(companyId)}, function (err, company) { 
        if (err) {
            return next(err);
        }
        return res.json(company.jobs);
    });

};

当用户向/api/v1/companies/:companyId/jobs发起 HTTP POST 请求时，postJobForCompany 回调函数将被调用。此回调将在 api.js 路由文件中定义。此路由将更新公司文档并嵌入作业文档。最后，它将返回更新后的公司文档：

exports.postJobForCompany = function (req, res, next) {
    var companyId = req.param('companyId');
    var job = {
        "title": req.body.title,
        "description": req.body.description
    }

    companies.update({"_id": mongojs.ObjectId(companyId)}, {$push: {"jobs": job}}, function (err, result) {
        if (err) {
            return next(err);
        }
        return companies.findOne({"_id": mongojs.ObjectId(companyId)}, function (err, company) {
            if (err) {
                return next(err);
            }

            return res.json(company);
        })
    })
};

要在本地机器上测试应用程序，启动 MongoDB 数据库服务器，然后重新启动 Node 应用程序。

为了使该应用程序在 OpenShift 上运行，你必须更新 bin/www 脚本：

#!/usr/bin/env node
var debug = require('debug')('jobstore');
var app = require('../app');
var ipaddress = process.env.OPENSHIFT_NODEJS_IP || "127.0.0.1";
var port = process.env.OPENSHIFT_NODEJS_PORT || 3000;
app.set('port', port);
app.set('ipaddress', ipaddress);
var server = app.listen(app.get('port'), app.get('ipaddress'), function() {
  debug('JobStore application running at http://%s:%d ',app.get('ipaddress'), app.get('port'));
});

这段代码设置了正确的 IP 地址和端口值，以便应用程序可以在 OpenShift 上运行。

将 node_modules 目录添加到 .gitignore 文件中，方法如下：
```
$ echo "node_modules/" > .gitignore
```
更新 package.json 中的 main 字段值。这是必要的，因为否则 OpenShift 会查找 server.js 文件。由于该应用程序没有 server.js 文件，应用程序将无法启动。这一点在 创建你的第一个 Node.js 应用程序 的教程中已做解释：
```
"main":"./bin/www",
```
将更改添加到 Git 索引，提交代码到本地 Git 仓库，然后最终将更改推送到应用程序服务器：
```
$ git add .
$ git commit -am "jobstore app"
$ git push
```
在成功构建后，更改将被部署，并且你的应用程序将可以通过 http://jobstore-{domain-name}.rhcloud.com 访问。

它是如何工作的……

现在让我们来理解一下我们在前面的步骤中做了什么。在第 3 步中，你安装了 express-generator 模块。在 Express 的早期版本中，express-generator 包是 Express 模块的一部分。现在，在最新版本中，你需要单独安装 express-generator。此教程使用的是 4.2.0 版本。该模块是通过 -g 选项全局安装的，以便能够从任何目录运行 Express 可执行文件。

接下来，在第 4 步中，你使用express . --ejs --force命令在jobstore目录下生成了项目。该命令指示 Express 在当前目录创建模板。--ejs选项告诉 Express 使用ejs模板引擎来配置应用。Express 支持几乎所有为 Node 构建的模板引擎，但 express-generator 仅支持hogan、jade和ejs。--force选项指示 Express 强制在非空目录中创建项目模板。如果不使用--force选项，生成器会要求你确认，如下所示：

destination is not empty, continue?

express命令生成了一个适合 Express Web 开发的文件夹结构，如下所示：

$ ls -p
app.js      bin/      package.json   public/      routes/      views/

package.json文件是基于 CommonJS 的应用描述文件 (wiki.commonjs.org/wiki/CommonJS)。它包含应用元数据及其依赖项。npm install命令解析package.json中提到的依赖项，并将它们安装到node_modules目录中。

app.js文件配置了 Express 框架以及 Connect 中间件组件。应用服务器启动的模板定义在bin/www脚本中。这是一个 Node 脚本，用于创建一个 Express Web 服务器并将其绑定到 3000 端口。要运行应用程序，你可以使用./bin/www或npm start命令。

Express 命令除了bin之外，还创建了另外三个子目录——public、routes和views。public目录存放了应用程序的所有静态资源。app.js文件配置 Express 应用以使用public目录中的静态文件：

app.use(express.static(path.join(__dirname, 'public')));

在第 6 步中，你从项目的 GitHub 仓库复制了css和js目录。

routes目录包含两个文件——index.js和users.js。这两个文件都被app.js使用。这些文件定义了当用户请求http://jobstore-{domain-name}.rhcloud.com和http://jobstore-{domain-name}.rhcloud.com/users URL 时将调用的回调函数。

views目录存放了将展示给用户的模板文件。在第 6 步中，你将index.ejs更新为来自项目 GitHub 仓库的版本。如前所述，应用程序的视图是使用 Backbone.js 构建的，关于视图部分的内容不在本书的讨论范围内。

从第 7 步到第 12 步，你定义了该应用程序的 REST 后台。该应用程序暴露了一个由 MongoDB 数据库支持的 REST 调用，供 Backbone.js 前端使用。你创建了一个名为api.js的新文件，用于定义所有的 API 回调。你安装了mongojs包，以便可以与 MongoDB 数据库进行交互。你在api.js中定义了四个方法——companies、saveCompany、jobsForCompany和postJobForCompany。所有方法都异步操作 MongoDB 数据库，并将数据库结果写入响应对象。

在app.js中，你定义了四个 REST 端点的路由。回调函数在api.js中定义，如下所示：

app.get('/api/v1/companies', api.companies);
app.post('/api/v1/companies', api.saveCompany)
app.get('/api/v1/companies/:companyId/jobs', api.jobsForCompany);
app.post('/api/v1/companies/:companyId/jobs', api.postJobForCompany);

在编写完后端逻辑后，你更新了bin/www脚本，以便在 OpenShift 上运行时能够绑定并监听正确的 IP 地址和端口。

最后，你提交了代码并将更改推送到应用的 gear。这将下载node_modules目录中提到的所有依赖项，并使用更新后的代码重新启动应用。

另见

创建你的第一个 Node.js 应用示例
启用 Node.js 应用的热部署示例
使用 Web Sockets示例

使用 Web Sockets

HTTP 被设计为半双工，这意味着它一次只允许一个方向的数据传输。这使得它不适用于构建需要始终保持打开的持久连接的实时应用程序。为了克服 HTTP 的这一局限性，开发者创建了一些解决方法或变通方法。这些变通方法包括轮询、长轮询和流式传输。

Web Sockets 提供了一个异步、双向、全双工的消息传递实现，所有通信都通过单一的 TCP 连接进行。在这个示例中，你将学习如何使用 Socket.IO 和 Express 来创建一个简单的回显应用。该应用简单地反转消息并将其回显到用户的浏览器。

准备工作

要完成这个示例，你需要在你的机器上安装 rhc 命令行客户端。详情请参考第一章中的安装 OpenShift rhc 命令行客户端示例，OpenShift 入门。此应用将消耗一个 gear，因此如果你没有额外的 gear 可用，请使用rhc delete app <app_name> --confirm命令删除一个现有应用。要在本地机器上运行此应用，你需要在机器上安装 Node。你可以从 Node.js 的官方网站（nodejs.org/download/）获取适合你操作系统的最新安装程序。

如何实现…

执行以下步骤来创建一个使用 Web Sockets 的应用：

打开一个新的命令行终端，并导航到你希望创建应用的方便位置。运行以下命令以创建应用：
```
$ rhc create-app reverseecho nodejs-0.10
```
切换到reverseecho目录，并删除模板应用的源代码：
```
$ cd reverseecho
$ rm -rf deplist.txt index.html node_modules/ package.json server.js
```
通过执行以下命令，将node_modules目录添加到.gitignore文件中：
```
$ echo "node_modules/" > .gitignore
```

创建一个package.json文件：

{
  "name": "reverse-echo",
  "version": "0.0.1",
  "private": true,
  "main": "server.js"
}

按照以下方式安装express和socket.io模块：

$ npm install express –save
$ npm install socket.io --save

在应用根目录创建一个名为server.js的新文件，并填充以下代码：

var express = require("express");
var app = express();
var server = require('http').createServer(app);
var ip = process.env.OPENSHIFT_NODEJS_IP || '127.0.0.1';
var port = process.env.OPENSHIFT_NODEJS_PORT || 3000;
server.listen(port,ip);
var io = require('socket.io').listen(server);

app.get('/',function(req,res){
   res.sendfile(__dirname+'/index.html');
});
console.log('App running at http://%s:%d',ip,port);
io.sockets.on('connection', function (socket) {

   // when the client emits 'sendchat', this listens and executes
   socket.on('message', function (data) {
      io.sockets.emit('rev-message', data.split("").reverse().join(""));
   });
});

在这段代码中，首先创建了一个 Express 服务器应用实例。然后，导入了 Socket.IO 库并启动了 Socket.IO 服务器，提供已经创建的 Express 服务器，使其可以共享相同的 TCP/IP 地址和端口。你使用io.sockets.on()函数定义了一些事件监听器。io.sockets.on()函数接受两个参数——事件名称和回调函数。事件名称可以是任何字符串，例如'connection'和'message'。回调函数定义了在接收到事件时要执行的操作。

在app根目录下创建index.html，并用以下代码填充它。此页面有一个文本框，用户可以在其中输入任何文本，并通过按下按钮将其提交到服务器。数据通过 Web Socket 传输到服务器。

<html>
<head>
   <title>ReverseEcho</title>
application   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <link href="//cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.1.1/css/bootstrap.css" rel="stylesheet">
   <style type="text/css">
    body {
      padding-top:60px;
      padding-bottom: 60px;
    }
  </style>
</head>
<body>
<div class="container">
   <div class="row">
      <div class="col-md-6">
         <input type="text" class="form-control" rows="3" id="message" placeholder="Write a message">
      <input type="button" id="echobutton" value="Reverse Echo" />
      </div>
      <div class="col-md-6">
         <p id="result"></p>
      </div>
   </div>
</div>

<script src="img/socket.io.js"></script>
<script src="img/jquery.min.js"></script>
<script>
        var wsUrl;
        if(window.location.host == '127.0.0.1:3000'){
          wsUrl = window.location.protocol + "//" + window.location.host;
        }else{
          if (window.location.protocol == 'http:') {
          wsUrl = 'ws://' + window.location.host + ':8000/';
        } else {
          wsUrl = 'wss://' + window.location.host + ':8443/';
          }  
        }
        console.log('WebSockets Url : ' + wsUrl);
        var socket = io.connect(wsUrl);
        socket.on('connect', function(){
          console.log('User connected');
        });
        socket.on('rev-message', function (data) {
                $('#result').text(data);
        });
        $(function(){
                $('#echobutton').click( function() {
                        var message = $('#message').val();
                        $('#message').val('');
                        socket.emit('message', message);
                });
        });

</script>
</body>
</html>

index.html文件中的这段 JavaScript 代码打开了与部署在 OpenShift 上的后端 Node 服务器的 Web Socket 连接。在 OpenShift 中，由于官方 OpenShift 博客中提到的原因，www.openshift.com/blogs/paas-websockets，Web Socket 不能通过标准的 80 和 443 端口使用，因此你需要使用端口号 8000 和 8443。

将代码添加到 Git 索引，提交代码到本地 Git 仓库，然后通过执行以下命令将更改推送到应用程序环境：
```
$ git add .
$ git commit -am "OpenShift Node Web Socket application"
$ git push
```
部署代码后，你可以看到应用运行在http://reverseecho-{domain-name}.rhcloud.com。如果你输入OpenShift并点击Reverse Echo按钮，你将看到tfihSnepO作为结果。如下所示的屏幕截图：How to do it…

它是如何工作的…

在前面的步骤中，你构建了一个回显服务器，该服务器会反转用户发送的消息并将其发送回用户。为了构建这个应用，你安装了两个模块——Socket.IO 和 Express，正如第 3 步所讲的那样。Socket.IO 为 Node.js 和客户端 JavaScript 提供了 Web Socket 及其他传输的 API 抽象。如果 Web Socket 在浏览器中没有实现，它会透明地回退到其他替代方案，同时保持相同的 API。

第 4 步中显示的代码清单执行以下操作：

它首先使用require()函数导入 Express 库，然后使用 Express 应用对象创建服务器。
然后，它导入了 Socket.IO 库，并使用listen()函数启动 Socket.IO 服务器。
接下来，定义了根 URL 的路由，该路由将渲染index.html（在下一步中创建）。
最后，添加了连接和消息事件的事件处理程序。在连接事件中，你将在服务器日志中写入一条消息。在消息事件中，你将反转消息并触发rev-message事件。客户端将监听rev-message事件，并渲染用户界面。

在第 5 步所示的列表中，你创建了一个使用 Twitter Bootstrap 样式的 index.html 文件。该 script 标签的作用如下：

在页面加载时，你使用后端 Web Socket URL 连接到 Web Socket 后端。在 OpenShift 中，由于本文博客中所述的原因，Web Sockets 无法通过标准的 80 和 443 端口使用，因此你必须使用端口号 8000 和 8443。你构建了正确的 URL，然后与 Socket.IO 后端建立了连接。
你添加了 connect 和 rev-message 事件的监听器。
当接收到 rev-message 事件时，你会将消息写入 results div 中。
你添加了一个 jQuery 事件监听器，当按钮被按下时，它会触发消息事件。该消息将被 Socket.IO 服务器后端接收，然后触发 rev-message 事件。

在第 7 步中，你提交了代码并将更改推送到应用程序 gear。这将下载所有依赖项，并用更新的代码重启应用程序。最后，在第 8 步中，你在浏览器中测试了反向回显功能。

另见

使用 Node.js 和 MongoDB 卡片创建和部署 Express Web 应用程序 配方
创建你的第一个 Node.js 应用程序 配方

在 OpenShift Node.js 应用程序中使用 CoffeeScript

在本章的最后一个配方中，你将学习如何在 OpenShift Node.js 应用程序中使用 CoffeeScript。你将开发一个使用 CoffeeScript 编写的 Express Web 应用程序，并将其部署到 OpenShift。

准备工作

为完成此配方，你需要在你的机器上安装 rhc 命令行客户端。详细信息请参见第一章中的 安装 OpenShift rhc 命令行客户端 配方，OpenShift 入门。此应用程序将消耗一个 gear，因此如果你没有额外的 gear 可用来完成此配方，请使用 rhc delete app <app_name> --confirm 命令删除现有应用程序。要在本地机器上运行此应用程序，你需要在机器上安装 Node。你可以从 Node.js 的官方网站获取适用于你的操作系统的最新安装程序（nodejs.org/download/）。

如何操作…

按照以下步骤创建一个 CoffeeScript Express 应用程序：

打开一个新的命令行终端，导航到你希望创建应用程序的位置。运行以下命令来创建应用程序：
```
$ rhc create-app myapp nodejs-0.10
```
切换到 myapp 目录，并删除模板应用程序源代码。
```
$ cd myapp
$ rm -rf deplist.txt index.html node_modules/ package.json server.js
```
通过执行以下命令将 node_modules 目录添加到 .gitignore 文件中：
```
$ echo "node_modules/" > .gitignore
```
创建一个 package.json 文件来存储你的应用程序元数据和依赖项，如下所示：
```
{
  "name": "myapp",
  "version": "0.0.1"
}
```
使用 npm 安装 CoffeeScript 和 Express 模块，如下所示：
```
$ npm install express coffee-script --save
```

创建一个新文件 app.coffee，并在其中放入以下内容。这是使用 CoffeeScript 编写的 Hello World Express Web 应用程序：

express = require('express')
app = express()
ip = process.env.OPENSHIFT_NODEJS_IP || '127.0.0.1'
port = process.env.OPENSHIFT_NODEJS_PORT || 3000
# App Routes
app.get '/', (request, response) ->
  response.send 'Hello World!!'

# Listen
app.listen port,ip
console.log "Express server listening on port http://%s:%d", ip,port

创建use_npm标记文件，以告知 OpenShift 你希望使用npm start命令来运行应用程序：
```
$ touch .openshift/markers/use_npm
```

使用启动脚本更新package.json文件：

{
  "name": "myapp",
  "description": "My OpenShift Node.js Application",
  "version": "0.0.1",
  "dependencies": {
    "express": "~4.3.1",
    "coffee-script": "~1.7.1"
  },
  "scripts":{"start":"~/app-root/runtime/repo/node_modules/.bin/coffee app.coffee"}
}

该启动脚本利用了node_modules/.bin目录中的coffee可执行文件。node_modules目录位于$OPENSHIFT_REPO_DIR目录内。

将代码添加到 Git 索引中，将代码提交到本地 Git 仓库，然后通过执行以下命令将更改推送到应用程序设备：
```
$ git add .
$ git commit -am "OpenShift Node CoffeeScript application"
$ git push
```

它是如何工作的…

CoffeeScript 是一种编程语言，它将代码转译成 JavaScript。CoffeeScript 的语法灵感来自于 Python 编程语言。因此，使用 CoffeeScript 编写的代码往往简洁易读。许多不喜欢 JavaScript 语法的开发者更倾向于使用 CoffeeScript 来构建他们的 Node 应用程序。从第 1 步到第 5 步，你使用 CoffeeScript 构建了一个Hello World Express Web 应用程序。要运行 CoffeeScript 代码，你需要来自coffee-script包的coffee可执行文件。coffee可执行文件位于node_modules/.bin目录中。

要在本地机器上运行 CoffeeScript 应用程序，你可以使用npm install coffee-script -g命令全局安装coffee-script模块。这将全局安装coffee可执行文件，使你能够在任何地方运行coffee命令。但这在 OpenShift 中不起作用。如果你在第 5 步后推送代码，管理进程将无法启动应用程序，因为它找不到coffee可执行文件。use_npm标记可以解决这个问题。正如使用 use_npm 标记中的说明，通过use_npm标记，你可以指定自己的启动脚本。OpenShift 将使用package.json中的启动脚本来运行应用程序。在第 7 步中，你定义了启动脚本，它将使用$OPENSHIFT_REPO_DIR/node_modules/.bin目录中的coffee可执行文件来运行应用程序。

另请参阅

使用 Node.js 和 MongoDB 组件创建并部署 Express Web 应用程序食谱
创建你的第一个 Node.js 应用程序食谱

第十章：OpenShift 应用程序的持续集成

本章将帮助您使用 Jenkins 插件为您的 OpenShift 应用程序添加持续集成。具体内容如下：

将 Jenkins CI 添加到您的应用程序
增加从属机空闲超时
安装 Jenkins 插件
使用 Jenkins 构建托管在 GitHub 上的项目
为您的 OpenShift 应用程序创建 Jenkins 工作流
升级 Jenkins 到最新版本

介绍

在本章中，您将学习如何为您的 OpenShift 应用程序添加持续集成（CI）支持。CI 是极限编程（XP）的一项实践，它通过工具监控您的版本控制系统（如 Git 或 SVN）中的代码更改。每当检测到更改时，它会构建项目并运行测试用例。如果构建由于某种原因失败，工具会通过电子邮件或其他通讯渠道通知开发团队故障情况，以便他们能够立即修复构建失败。CI 工具不仅仅用于构建和测试应用程序。它们还可以跟踪代码质量、运行功能测试、执行自动部署、应用数据库迁移以及执行其他许多任务。这有助于我们在软件开发周期的早期发现缺陷，提高代码质量，并自动化部署。

OpenShift 将 Jenkins 作为其首选的 CI 工具。Jenkins (jenkins-ci.org/) 是目前市场上最主流、最受欢迎的 CI 服务器。它是一个用 Java 编程语言编写的开源项目。Jenkins 功能丰富，并通过插件进行扩展。您可以使用来自活跃社区的超过 600 个 Jenkins 插件，这些插件能够涵盖版本控制系统、构建工具、代码质量度量、构建通知器等几乎所有功能。

将 Jenkins CI 添加到您的应用程序 这一方法将帮助您将 Jenkins 集成到现有的 OpenShift 应用程序中。我们将使用 Java 应用程序展示 OpenShift 和 Jenkins 的集成。本章主要讨论 Jenkins 与 Java 应用程序的结合。然而，即使您使用的是 OpenShift 支持的其他 Web 插件，本章也能帮助您充分理解如何为您的应用程序添加 OpenShift Jenkins CI 支持。

OpenShift 使用 Jenkins 主/从拓扑结构（wiki.jenkins-ci.org/display/JENKINS/Distributed+builds）来分配构建任务给不同的从节点。这确保你为 OpenShift 应用程序提供一个可扩展的 Jenkins 环境。此外，Jenkins 主节点将创建不同类型的从节点来构建不同类型的 OpenShift 应用程序。从节点的类型取决于应用程序的类型。例如，为了构建 JBoss EAP 应用程序，Jenkins 主节点将创建一个安装了 JBoss EAP 插件的从节点。默认情况下，从节点在 15 分钟无操作后会被销毁。增加从节点空闲超时时间的配方将讲解如何增加从节点的空闲超时时间。

插件使 Jenkins 可扩展，允许你扩展 Jenkins 以满足你的需求。在安装 Jenkins 插件的配方中，你将学习如何安装 Jenkins 插件。你可以在 wiki.jenkins-ci.org/display/JENKINS/Plugins 查看 Jenkins 插件的完整列表。

你不仅可以使用 Jenkins 构建托管在 OpenShift 上的应用程序，还可以构建托管在其他地方的项目。使用 Jenkins 构建托管在 GitHub 上的项目 的配方将涵盖如何构建托管在 GitHub 上的项目。

为你的 OpenShift 应用程序创建 Jenkins 工作流 的配方将展示如何根据你的需求自定义 OpenShift 默认创建的构建。在这个配方中，你将创建一个 Jenkins 工作流，包括三个 Jenkins 任务。第一个 Jenkins 任务将轮询 Git 仓库以查找更改，第二个任务将对应用程序源代码进行代码覆盖率检查，第三个任务将把应用程序部署到 OpenShift。

OpenShift 支持的 Jenkins 版本并不是最新版本。在将 Jenkins 升级到最新版本的配方中，你将把 Jenkins 升级到最新版本。使用最新版本的优点在于，某些插件与 OpenShift 支持的 Jenkins 版本不兼容。

Jenkins 并不是你唯一可以用来构建和部署 OpenShift 应用程序的 CI 服务器。你也可以使用托管的 CI 服务器，如 Travis CI，来构建和部署 OpenShift 应用程序。OpenShift 和 Travis CI 的集成在本章中没有介绍，但你可以参考我的博客，了解更多相关信息，链接：www.openshift.com/blogs/how-to-build-and-deploy-openshift-java-projects-using-travis-ci。

将 Jenkins CI 添加到你的应用程序中

将 Jenkins 添加到你的应用程序是一个两步过程。你需要先创建 Jenkins 服务器应用程序，然后将 Jenkins 客户端插件添加到你的应用程序中。在本教程中，你将学习如何将 Jenkins CI 添加到现有的 OpenShift 应用程序中。添加 Jenkins 到应用程序后，每次向 OpenShift 应用程序的 Git 仓库推送代码时，都会启动一个 Jenkins 作业，构建该项目并将其部署到 OpenShift。

准备工作

要完成本教程，你将需要三个可用的 Gear。一个 Gear 将由应用程序使用，Jenkins 将使用其余的两个 Gear。本章将使用第七章中创建的应用程序，OpenShift for Java 开发者。如果你没有运行该应用程序，可以使用以下命令重新创建应用程序：

$ rhc app create jobstore jbosseap postgresql-9.2 --from-code https://github.com/OpenShift-Cookbook/chapter7-jobstore-javaee6.git

如何操作…

执行以下步骤将 Jenkins 添加到你的应用程序中：

在你将 Jenkins 插件添加到应用程序之前，必须先创建 Jenkins 服务器应用程序：
```
$ rhc create-app jenkins jenkins
```
执行上述命令后，Jenkins 服务器将在 http://jenkins-{domain-name}.rhcloud.com 上可用。请将 {domain-name} 替换为你的 OpenShift 账户域名。

记下 OpenShift rhc 命令行客户端在应用程序创建日志中向你展示的用户名和密码。这些信息用于登录 Jenkins Web 控制台。以下是命令行输出的示例：

Creating application 'jenkins' ... done
 Jenkins created successfully.  Please make note of these credentials:
 User: admin
 Password: xxxxxx
Note:  You can change your password at: https://jenkins-{domain-name}.rhcloud.com/me/configure

使用第 1 步中获得的凭据登录 Jenkins：https://jenkins-{domain-name}.rhcloud.com/me/configure。我建议你将 Jenkins 密码更改为容易记住的内容。要更改密码，请在密码部分输入新密码，并点击保存按钮：
保存新密码后，登出并使用新密码重新登录。你将看到如下所示的 Jenkins 仪表板截图：
现在你已经创建了 Jenkins 服务器应用程序，可以将 Jenkins 插件添加到 jobstore 应用程序中。要添加插件，请运行以下命令：
```
$ rhc add-cartridge jenkins --app jobstore
```
访问 Jenkins 仪表板 https://jenkins-{domain-name}.rhcloud.com/，你将看到为 jobstore 应用程序配置的新作业，如下图所示：
点击 jobstore-build 链接（https://jenkins-{domain-name}.rhcloud.com/job/jobstore-build/）查看 Jenkins 作业详情。
要启动一个新的构建，你可以点击左侧的立即构建链接，或者对项目源代码进行更改，提交并将更改推送到应用程序的 Git 仓库。让我们对应用程序源代码做一个小更改。将 src/main/webapp/index.html 文件中的标题从 <title>JobStore</title> 更改为 <title>带有 Jenkins 的 JobStore</title>：
```
$ git commit -am "updated title"
$ git push
```

git push 日志会显示 Jenkins 正在构建项目，日志内容如下：

remote: Executing Jenkins build.
remote: You can track your build at https://jenkins-xxxx.rhcloud.com/job/jobstore-build
remote: 
remote: Waiting for build to schedule................................Done
remote: Waiting for job to complete..............................

你可以通过点击控制台输出选项，在 Jenkins 网络控制台查看构建日志，如下图所示：
完成工作后，你可以在构建历史下查看构建状态。成功的构建会显示为蓝色，失败的构建会显示为红色。
你可以通过在你喜欢的浏览器中打开应用程序的 URL (http://jobstore-{domain-name}.rhcloud.com) 来验证你的更改是否已应用。你会看到标题已更新为带有 Jenkins 的 Jobstore。

它是如何工作的……

Jenkins 的一个强大功能是它能够将构建分布到多个机器上。Jenkins 使用主/从架构来管理分布式构建。在主/从架构中，有一个 Jenkins 服务器，负责调度作业，将构建分派到从服务器进行实际执行，监控从服务器的健康状态，并记录和展示构建结果。从服务器执行实际的构建并将作业结果与主服务器共享。

OpenShift 使用 Jenkins 的主/从架构来构建你的应用程序。每个 OpenShift 域只能有一个 Jenkins 主服务器，且该域下的所有应用程序都将使用该 Jenkins 主服务器进行应用构建。根据该应用程序的 Jenkins 作业配置，Jenkins 主服务器会创建一个从服务器来构建该应用程序。每个 OpenShift Jenkins 安装都会安装 OpenShift Jenkins 插件。这个插件使得 Jenkins 能够与 OpenShift 账户进行通信，并代表你创建从服务器。Jenkins 从服务器不过是 OpenShift 的 gears。

在第 1 步中，你创建了 Jenkins 主应用程序。你可以使用主实例直接执行任务，但在主/从架构中，大多数情况下是使用从实例来构建项目。OpenShift 创建的 Jenkins 主实例被配置为不运行任何任务，方法是将执行器的数量配置为0。执行器数量允许你定义一个实例可以并发运行的任务数量。由于主实例的执行器数量被设置为0，你不能用它来构建任何项目。你可以通过更新 Jenkins 配置屏幕中的执行器数量系统配置值（https://jenkins-{domain-name}.rhcloud.com/configure）将执行器数量设置为大于0的数字，如下图所示。在使用 Jenkins 构建托管在 GitHub 上的项目食谱中，你将使用 Jenkins 主实例来构建项目。请看下图：

一旦你创建了 Jenkins 主应用程序，你就可以将 Jenkins 客户端添加到jobstore应用程序中。如果你在创建 Jenkins 主应用程序之前尝试将 Jenkins 客户端添加到应用程序中，你会在rhc add-cartridge命令日志中看到错误消息。

在第 5 步中，你将 Jenkins 客户端插件添加到jobstore应用程序中。Jenkins 客户端插件为jobstore项目创建了一个新的 Jenkins 任务。在 Jenkins 中，任务定义了需要完成的工作。你可以通过在浏览器中打开https://jenkins-{domain}.rhcloud.com/job/jobstore-build/configure来查看任务配置。

任务配置可以分为三个部分：构建器配置、源代码管理配置和构建配置。

构建器配置：下图所示的配置值将用于创建一个从实例。该配置表示需要一个类型为redhat-jbosseap-6的小型齿轮大小的从实例。这意味着该从实例将安装 JBoss EAP 6 插件。它还定义了 Jenkins 主实例等待从实例上线的超时时间。默认的构建器超时时间是5分钟或300000毫秒。限制此项目可以运行的地方配置定义了该项目将只在标有jobstore-build标签的从实例上构建。你可能已经注意到，标签的名称与任务的名称相同。OpenShift Jenkins 插件使用标签名称读取任务配置，并使用任务的构建器配置创建一个从实例。因此，如果你将标签名称从jobstore-build更改为jobstore-os-build，则 Jenkins 插件将无法找到关联的任务配置，任务也将无法执行。
Git 配置：下一个重要的配置是 Git 版本控制配置。此配置指定应用程序的 Git 仓库 URL。Jenkins 作业将使用指定的 Git 仓库 URL 克隆该 Git 仓库并构建此项目。以下截图显示了 Git 配置：
构建配置：这是我们作业配置中最重要的部分。它定义了需要做什么。作业配置如下截图所示。配置完成以下任务：
1. 它通过 Git 和rsync从实际应用程序下载内容到构建器应用程序。
2. 如果没有force_clean_build标记，它还会将实际应用程序中的$OPENSHIFT_BUILD_DEPENDENCIES_DIR和$OPENSHIFT_DEPENDENCIES_DIR目录的内容复制到构建器应用程序中。当存在force_clean_build标记时，依赖项将在构建器应用程序上重新下载，构建将花费更多时间才能完成。
3. 然后，它使用任何与卡带相关的构建命令来构建应用程序。对于 Java 应用程序，它将使用mvn clean install –Popenshift –DskipTests命令。
4. 构建成功完成后，它会停止应用程序的 gear。
5. 然后，Jenkins 使用rsync将新内容从构建器应用程序复制到实际应用程序。
6. 最后，它启动了应用程序。请查看以下截图：

如果你的应用程序中没有启用 Jenkins，那么代码将在应用程序运行的同一 gear 上构建。当你将更改推送到应用程序 gear 时，OpenShift 首先停止你的应用程序，构建应用程序，部署产物，最后启动应用程序。

在第 8 步中，添加 Jenkins 卡带到jobstore应用程序后，你对源代码进行了更改并将更改推送到应用程序 gear。这一次，Jenkins 服务器启动一个从节点并发起构建，而不是在应用程序 gear 上构建项目。以下步骤详细解释了这个过程：

用户进行更改并通过git push命令将更改推送到应用程序 gear。
在接收到数据后，调用 Git 动作钩子，通知 Jenkins 服务器。

Jenkins 服务器创建一个专用的 Jenkins 从节点（构建器）来构建这个项目。你可以通过rhc apps命令查看 Jenkins 创建的新 gear：

jobstorebldr @ http://jobstorebldr-xxxx.rhcloud.com/ (uuid: 539b660ce0b8cdeba00000e1)
----------------------------------------------------------------------------------------
Domain:     xxxx
Created:    2:28 AM
Gears:      1 (defaults to small)
Git URL:    ssh://539b660ce0b8cdeba00000e1@jobstorebldr-xxxx.rhcloud.com/~/git/jobstorebldr.git/
SSH:        539b660ce0b8cdeba00000e1@jobstorebldr-xxxx.rhcloud.com
Deployment: auto (on git push)

jbosseap-6 (JBoss Enterprise Application Platform 6)
----------------------------------------------------
Gears: 1 small

Jenkins 使用构建配置部分中提到的步骤运行构建。在构建成功后，构建产物将通过rsync工具复制到应用程序 gear，如构建配置中所提到的。
Jenkins 在构建成功后启动应用程序，然后归档构建产物，供以后使用。
在 15 分钟的空闲时间后，Jenkins 构建器会被销毁，并且在rhc apps命令的输出中不再显示。然而，构建产物仍会保存在 Jenkins 中，可以在那里查看。

将 Jenkins 与 OpenShift 应用配合使用有以下优点：

构建失败时不影响应用运行：在没有 Jenkins 支持的情况下，OpenShift 会在与你的应用运行的同一设备上运行构建。它首先停止该设备上的所有插件，执行构建，并最终部署成功的构建产物。如果构建失败，构建产物将不会被部署，你的应用将会停机。启用了 CI 后，OpenShift 只会在构建成功完成后才停止应用。这样就能避免因构建失败而导致的停机。
更多资源来构建你的项目：由于 Jenkins 构建器运行在独立的设备上，它们具有额外的资源，如内存和存储，以便运行你的应用构建。
存储以前的构建：Jenkins 可以为你存储之前成功的构建产物。如果你希望回滚到先前的版本，可以使用这些构建产物。
Jenkins 插件：Jenkins 拥有一个强大而活跃的社区，开发了各种插件来执行常见任务。你可以使用这些插件来自动化应用的各种任务。在本章中，你将安装多个 Jenkins 插件来完成不同的任务。

你可以使用以下命令查看 Jenkins 服务器的日志：

$ rhc tail --app jenkins

另见

增加从属机空闲超时时间的操作步骤
安装 Jenkins 插件的操作步骤
为你的 OpenShift 应用创建 Jenkins 工作流的操作步骤

增加从属机空闲超时时间

Jenkins 主服务器会创建从属机来构建项目。这些从属机在构建项目后只会存活 15 分钟，也就是说，只有在完成第一次构建后的 15 分钟内收到下一次构建请求时，从属机会被重用。如果在构建项目后 15 分钟内没有接收到构建请求，Jenkins 主服务器将会销毁从属实例。下一次构建请求将会重新创建一个新的从属机并在其上构建应用。创建从属机是一个耗时的过程，因此在开发周期中，当你需要快速反馈时，这并不是理想的做法。

在本操作步骤中，你将学习如何增加从属机空闲超时时间，以便你可以更长时间地重用从属机，并从 CI 服务器获得更快的反馈。

准备工作

本食谱假设你已经有一个启用了 Jenkins 的应用程序，正如将 Jenkins CI 添加到你的应用程序食谱中所讨论的那样。

操作步骤…

执行以下步骤：

登录到你的 Jenkins 仪表板，然后前往 Jenkins 配置页面，地址为https://jenkins-{domain-name}.rhcloud.com/configure。
在Cloud配置部分下，存在一个Slave Idle Time to Live配置，如下图所示。默认配置为 15 分钟。
将Slave Idle Time To Live值更新为60分钟，并通过点击Save按钮保存配置。

工作原理…

OpenShift 创建的 Jenkins 主节点捆绑了一些 Jenkins 需要有效运行的插件。你可以通过导航到Plugin Manager | Installed查看所有已安装的插件，如下图所示：

使 Jenkins 能够与 OpenShift 帐户通信的插件是OpenShift Origin Jenkins Cloud Plugin。该插件负责管理构建应用程序的从机实例。

大多数 Jenkins 插件都有全局配置和作业级别配置。全局配置适用于所有 Jenkins 作业，而作业级配置仅适用于特定 Jenkins 作业。你可以通过访问https://jenkins-{domain-name}.rhcloud.com/configure的Configure System屏幕查看 Jenkins 的全局配置。你将安装的许多插件也需要在此进行配置。安装插件时，Jenkins 会动态添加新字段。

默认屏幕包含多个部分，用于配置一般的系统级参数或各种插件配置。OpenShift Jenkins 插件在Cloud部分下添加了OpenShift Cloud子部分。此配置用于与 OpenShift 帐户通信并创建构建应用程序所需的从机。

在前述步骤中，你将 OpenShift Cloud配置部分中的从机空闲超时增加到 60 分钟。这是你可以为从机设置的最大空闲超时时间。Jenkins 将创建的下一个从机将使用此配置，并在构建项目后保持 60 分钟的存活时间。

另见

将 Jenkins CI 添加到你的应用程序食谱
安装 Jenkins 插件食谱
为你的 OpenShift 应用程序创建 Jenkins 工作流食谱

安装 Jenkins 插件

Jenkins 的可扩展架构使其非常强大。通过第三方插件，你可以为 Jenkins 实例添加额外功能。这些功能让你可以与不同的 SCM 工具（如 Git）合作，生成代码质量和代码覆盖率报告，或自动化其他手动任务，如数据库模式迁移等。在本配方中，你将学习如何将 Green Balls 插件（wiki.jenkins-ci.org/display/JENKINS/Green+Balls）安装到你的 OpenShift Jenkins 实例中。Green Balls 插件让 Jenkins 在成功构建时使用绿色球代替蓝色球。

准备工作

本配方假设你已经有一个启用了 Jenkins 的应用程序，如将 Jenkins CI 添加到你的应用程序配方中所述。

如何操作…

执行以下步骤以安装插件：

登录到你的 OpenShift Jenkins 仪表板，进入https://jenkins-{domain-name}.rhcloud.com/manage的管理 Jenkins屏幕。管理 Jenkins屏幕是配置 Jenkins 系统所有方面的中心位置。
接下来，点击管理插件来管理 Jenkins 插件。你可以通过管理插件屏幕安装、移除或更新插件。请查看以下截图：
管理插件屏幕分为四个标签：更新、可用、已安装和高级，如下图所示：

更新标签显示所有有更新的已安装插件，可用标签显示所有可以安装到 Jenkins 实例中的插件，已安装标签显示已经安装在 Jenkins 实例中的插件，高级标签允许你手动安装插件或强制 Jenkins 检查更新。
Jenkins 插件注册表中所有可用的插件都显示在可用标签中。如果点击可用标签，你会发现列表是空的。为了让 Jenkins 在可用标签下显示插件，请前往管理插件 | 高级，然后点击立即检查按钮，如下图所示，强制检查是否有新更新：
完成后，你将看到可用标签下的插件列表。
要安装 Green Balls 插件，先过滤可用插件，然后点击无需重启安装。请查看以下截图：
插件安装后，你将看到 Green Balls 插件在运行。如果你仍然看到蓝球，请清除浏览器缓存。

它是如何工作的…

在之前的步骤中，您已将 Green Balls 插件安装到 OpenShift Jenkins 实例中。Green Balls 插件顾名思义：它使成功的构建显示为绿色球，而不是默认的蓝色球。

有几种方法可以将插件安装到 Jenkins 实例中。您可以使用自动方法或手动方法。在之前的步骤中，您使用了自动方法安装插件。自动方法适用于在 Jenkins 中央插件注册表中列出的插件，您可以通过updates.jenkins-ci.org/download/plugins/访问该注册表。对于不在中央插件注册表中的插件，需要手动安装。要手动安装插件，请导航到管理 Jenkins | 管理插件 | 高级。在高级选项卡中，有一个名为上传插件的部分，您可以用它来上传插件。点击选择文件按钮，选择本地机器中的插件，然后点击上传按钮上传插件：

手动安装的插件在重新启动 Jenkins 之前不会被安装。因此，一旦插件上传完成，您可以通过访问https://jenkins-{domain-name}.rhcloud.com/safeRestart来重新启动 Jenkins。这将在当前构建完成后重启 Jenkins，并安装您的插件。

另请参见

将 Jenkins CI 添加到您的应用程序指南
使用 Jenkins 构建托管在 GitHub 上的项目指南
为您的 OpenShift 应用程序创建 Jenkins 工作流指南

使用 Jenkins 构建托管在 GitHub 上的项目

您也可以使用 OpenShift Jenkins 实例来构建您的非 OpenShift 项目。本指南将使用一个基于 Maven 的公开托管在 GitHub 上的项目，地址为github.com/OpenShift-Cookbook/chapter10-demo-app。本指南的目标是在您向 GitHub 仓库推送代码时构建该项目，并在构建状态发生变化时发送电子邮件，即构建失败或从构建失败中恢复。这是组织尝试引入 CI 的第一步。

准备工作

本指南假设您已经有一个启用了 Jenkins 的应用程序，如将 Jenkins CI 添加到您的应用程序指南中所讨论的那样。

如何操作…

执行以下步骤以了解如何构建托管在 GitHub 上的项目：

在这个步骤中，我们将使用 Jenkins 主服务器来构建项目。访问https://jenkins-{domain-name}.rhcloud.com/configure，并将执行器数量属性更新为1。任何大于0的数字都会允许主服务器运行构建任务。此外，将使用情况字段值更改为仅为绑定任务保留此机器。这个配置确保主实例只用于明确配置为在主服务器上运行的任务。稍后在任务配置中，你将配置一个仅在主服务器上运行的任务。点击保存按钮以保存新值：
这个步骤的目标之一是在项目变得不稳定时发送电子邮件。为了允许 Jenkins 发送电子邮件，你需要在 Jenkins 的配置系统界面中的电子邮件通知部分提供电子邮件设置。点击高级标签查看所有配置选项。以下截图中显示的配置使用 Gmail 发送电子邮件。这里展示 Gmail 只是为了演示。谷歌可能会给你发送一封邮件，说明有人在入侵你的账户，因为你的账户被从一个与平常不同的位置访问。理想情况下，你应该使用你所在组织的 SMTP 服务器配置。
你还可以发送测试电子邮件来检查配置。通过勾选测试配置并提供你想要发送电子邮件的电子邮件地址，来检查测试电子邮件配置。你将收到类似以下截图中所示的电子邮件：
你可能会发现在前述截图中一个令人烦恼的地方是，电子邮件的发件人部分还没有配置地址。你可以通过将系统管理员电子邮件地址属性从地址尚未配置更新为某个用户友好的地址来进行配置，如以下截图所示。完成此更改后，Jenkins 的通知电子邮件将以此地址作为发件人发送：
点击Fork按钮，Fork GitHub 仓库(github.com/OpenShift-Cookbook/chapter10-demo-app)。你需要使用有效的 GitHub 账户登录，才能 Fork 这个仓库。你必须 Fork 这个仓库，以便能够将你的更改推送到仓库中。
访问你的 Jenkins 仪表板，点击新建任务。查看以下截图：
选择构建一个自由风格的软件项目构建类型，并为它命名为chapter10-github-recipe-build，如下所示截图。点击确定来创建该任务：
接下来，你将看到作业配置页面，在该页面你可以配置此作业。你将更新的第一个配置位于源代码管理部分。由于项目托管在 GitHub 上，输入你想要构建的 GitHub 仓库的 URL。GitHub 仓库的 URL 将是https://github.com/<username>/chapter10-demo-app.git。其中，username对应你的 GitHub 用户名。下图显示了源代码管理部分：
接下来，你需要配置此构建何时触发。这个配置在构建触发器部分进行设置。在下图所示的配置中，你告诉 Jenkins 每分钟轮询一次 SCM。它使用的语法与 Unix/Linux 中的crontab相同。
现在，Jenkins 作业已经知道从哪里以及多频繁地获取源代码，下一步是告诉作业如何处理这些源代码。这通过定义构建步骤来实现。一个作业可以有一个或多个构建步骤。要添加一个新的构建步骤，点击添加构建步骤下拉菜单，并选择执行 Shell，如下图所示：
这将显示一个文本区域，你可以在其中输入想要运行的命令。在文本区域中输入mvn clean install命令。
你可以选择在作业中配置的下一个选项是构建项目之后该做什么。这是通过创建一个或多个构建后操作来定义的。我们来添加一个操作，当构建变得不稳定时发送电子邮件通知。在添加构建后操作下拉菜单中选择电子邮件通知。在收件人文本框中，提供一个以空格分隔的电子邮件地址列表，当构建失败时，邮件将发送给这些地址，如下图所示：
在你保存此作业之前，最后一个配置是将其配置为在主节点上运行。这通过勾选限制此项目可以运行的节点复选框，并为其指定用于构建项目的节点名称来完成，如下图所示：
现在，点击保存按钮保存配置。
为了测试新的 Jenkins 作业，首先在本地机器上克隆项目。克隆项目的命令如下所示。请将用户名替换为你的 GitHub 账户用户名。
```
$ git clone git@github.com:<username>/chapter10-demo-app.git
```
为了测试作业是否正常工作，让我们更改其中一个测试用例，使其失败。将MessageRepositoryTest中的断言从assertEquals(1, messages.size());更新为assertEquals(2, messages.size());。
提交代码，并将更改推送到你的 GitHub 仓库：
```
$ git commit -am "added test failure"
$ git push
```
Jenkins 将选择该更改并开始新的构建。构建将失败，你将收到包含作业日志的电子邮件。
现在，我们通过将assertEquals(2, messages.size());更改为assertEquals(1, messages.size());来修复构建失败。然后运行以下命令：
```
$ git commit -am "fixed test failure"
$ git push
```
再次，Jenkins 会检测到更改并启动新的构建。这一次，你将收到一封电子邮件，告知构建已恢复正常，如下图所示：

它是如何工作的……

你创建了一个自由风格的 Jenkins 任务，该任务每分钟轮询一次 Jenkins，如果检测到新的提交，它将构建项目。在第 1 步中，你更新了 Jenkins 主节点配置，以便它可以运行构建任务。默认情况下，Jenkins 主节点没有配置为运行任何构建任务。通过在 Jenkins 系统配置中将执行器数量设置为1，可以让 Jenkins 主节点运行构建任务。执行器数量允许你定义 Jenkins 实例可以执行多少并发构建。

电子邮件是最常用的沟通方式之一。在第 2 步中，你配置了 Jenkins 使用 Gmail 的 SMTP 设置来发送电子邮件。你可以通过 Gmail SMTP 服务器每天发送 99 封电子邮件，这对于大多数个人项目来说足够了，但对于你的组织项目，应该使用组织的 SMTP 服务器。

这个配方要求你拥有自己的 Git 仓库，Jenkins 会轮询该仓库。这样做是因为你必须将更改推送到自己的 Git 仓库，而无法将更改推送到其他人的 Git 仓库，除非你被添加为协作者。你在第 3 步中分叉了该仓库，因此你拥有了这个仓库的副本，可以在上面工作。

在第 4 步中，你创建了一个新的 Jenkins 任务，用于构建你在第 3 步中分叉的项目。你使用了一个自由风格的构建任务，因为它是最灵活的构建选项，可以用于构建任何类型的项目。

从第 5 步到第 9 步，你配置了任务，使得 Jenkins 每分钟轮询一次 Git 仓库，并使用 Jenkins 主节点来构建项目。在第 10 步保存任务后，你将看到你的新任务出现在 Jenkins 仪表盘上。Jenkins 将自动运行该任务进行第一次构建，因为该任务没有任何历史记录。在第一次运行任务后，Jenkins 将等待你 Git 仓库中的更改，然后开始另一次构建。

配置任务后，你在第 11 到第 15 步中通过更改本地仓库并将更改推送到 GitHub 来测试 Jenkins 任务。Jenkins 将在接下来的 1 分钟内轮询 Git 仓库，检测到更改并启动构建。

另见

为你的 OpenShift 应用程序创建 Jenkins 工作流 配方

为你的 OpenShift 应用程序创建 Jenkins 工作流

在这个配方中，你将创建一个 Jenkins 工作流，可以用来在 OpenShift 上构建和部署应用程序。

准备工作

本配方将涵盖从头开始的所有步骤，确保你拥有所有三个必要的齿轮。

如何操作…

执行以下步骤为您的 OpenShift 应用程序创建 Jenkins 工作流：

通过运行以下命令创建一个新的 Jenkins 服务器应用程序。该内容在将 Jenkins CI 添加到您的应用程序这一章节中有详细介绍。
```
$ rhc create-app jenkins jenkins
```
创建一个 OpenShift Apache Tomcat 7 应用程序，用于部署项目。由于我们不想克隆仓库（因为代码将托管在 GitHub 上），因此该项目将使用--no-git选项创建。--enable-jenkins选项将创建一个新的 Jenkins 作业，该作业将构建并在 OpenShift 上部署应用程序：
```
$ rhc create-app forumapp tomcat-7 postgresql-9 --enable-jenkins --no-git
```
登录到 Jenkins 仪表板，您将看到forumapp-build作业列在仪表板上。
按照使用 Jenkins 构建托管在 GitHub 上的项目这一章节中提到的步骤创建一个名为forumapp-github-build的新 Jenkins 作业。创建作业后，任何推送到 GitHub 仓库的更改都会导致 Jenkins 构建。
接下来，按照安装 Jenkins 插件这一章节中的说明安装 Jenkins Cobertura 插件。
插件安装完成后，创建另一个名为forumapp-quality-build的作业。但您可以使用forumapp-github-build作业作为模板，而不是从头开始创建作业。输入详细信息后，点击确定：
您将被引导至forumapp-quality-build作业配置页面。更新以下配置值以适应此作业：
1. 将限制此项目可以运行的值从master更改为forumapp-build。
2. 在构建触发器部分取消选中轮询 SCM。
3. 将执行 Shell命令从mvn clean install更改为mvn clean package -Pquality。
现在，您需要向forumapp-quality-build添加两个构建后操作，首先启动forumapp-build作业，该作业将在 OpenShift 上部署应用程序；其次，发布 Cobertura 代码覆盖率报告。添加构建后操作，以便在构建成功时触发forumapp-build。要添加 Cobertura 代码覆盖报告构建后操作，点击添加构建后操作钩子选项，选择发布 Cobertura 覆盖率报告，并为Cobertura xml 报告模式字段提供**/ target/site/cobertura/coverage.xml。
更新forumapp-quality-build作业配置后，点击保存按钮。
forumapp-github-build的责任之一是在作业成功完成后启动forumapp-quality-build作业。通过添加构建后操作来更新forumapp-github-build作业配置。添加构建其他项目构建后操作，以在构建成功时构建forumapp-github-build。添加构建后操作后，点击保存按钮：
现在你已配置了forumapp-github-build和forumapp-quality-build任务，你需要更新forumapp-build任务配置，从 GitHub 仓库拉取代码并将最新代码部署到 OpenShift。访问https://jenkins-{domain-name}.rhcloud.com/job/forumapp-build/configure，并添加一个新的执行 Shell构建步骤。该构建步骤将首先为 GitHub 仓库添加一个 Git 远程仓库，然后从 GitHub 仓库拉取代码。以下是相关命令：
```
$ git remote add upstream -m master https://github.com/<username>/chapter10-demo-app.git
$ git pull -s recursive -X theirs upstream master
```
请将用户名替换为你的 GitHub 账户用户名。确保构建操作钩子的顺序与下图所示的顺序一致：
点击保存按钮以保存配置。
现在，为了测试所有任务是否正确配置，请进入 Jenkins 仪表盘，手动启动forumapp-github-build任务。你也可以不手动启动任务，而是修改应用源代码并将更改推送到 GitHub 仓库。Jenkins 将检测到更改并开始构建过程。
所有构建成功完成后，你将在 Jenkins 仪表盘上看到所有构建处于健康状态，如下图所示：
要查看项目的代码覆盖率，请访问forumapp-quality-build页面，并点击Coverage Report以查看项目的代码覆盖率：

它是如何工作的…

在前面的步骤中，你创建了一个简单的工作流，包含三个 Jenkins 任务，每个任务负责特定的工作。第一个任务按照指定的间隔轮询 GitHub 仓库的代码更改，并在发现更改时构建项目。该任务构建项目并运行单元测试。它使用 Jenkins 主节点来构建项目。使用 Jenkins 进行像这样的轻量级任务的好处是，你不需要等待从节点的创建。你应该只在任务较轻时使用主节点，否则 Jenkins 主节点可能会因任务过多而宕机。

第一个构建，如果成功，将启动质量任务，运行应用代码的代码覆盖率。这次构建使用 Cobertura（cobertura.github.io/cobertura/）来识别 Java 应用程序中缺乏测试覆盖的部分。质量构建被配置为执行mvn clean install -Pquality命令。该命令将运行 Maven Cobertura 插件。Maven 插件将生成 HTML 和 XML 报告。XML 报告由 Jenkins 解析覆盖率结果。质量构建将使用 Jenkins 从节点而不是主节点，因为质量构建通常会消耗大量内存和 CPU 资源，你肯定不希望因一个任务让主节点宕机。

质量构建成功完成后，第三个 Jenkins 任务将把应用部署到 OpenShift。该任务也会使用 Jenkins 从节点。

另见

将 Jenkins 升级到最新版本 食谱

将 Jenkins 升级到最新版本

OpenShift 创建的 Jenkins 应用程序运行的是 Jenkins 的旧版本。写这篇文章时，OpenShift 创建的 Jenkins 应用程序运行的是 1.509.1 版本。这个版本已经很旧，某些 Jenkins 插件在此版本下无法正常工作。在本食谱中，您将学习如何将 Jenkins 升级到最新版本。写这篇文章时，Jenkins 的最新版本是 1.567。

注意

本食谱是实验性的，我不建议将其用于生产环境中的 Jenkins 实例。此食谱的目的是展示升级 Jenkins 版本是可行的。升级过程中可能会导致构建数据丢失或 Jenkins 实例损坏。因此，请先在您的测试环境中使用此食谱。

准备就绪

本食谱假设您已经有一个启用了 Jenkins 的应用程序，正如在 将 Jenkins CI 添加到您的应用程序 食谱中所讨论的那样。

如何操作…

执行以下步骤以升级 Jenkins 版本：

打开一个新的命令行终端，使用以下命令通过 SSH 连接到您的 Jenkins 应用程序：
```
$ rhc ssh --app jenkins
```
在 $OPENSHIFT_DATA_DIR 中创建一个名为 jenkins-latest-version 的新目录，然后使用 wget 运行以下命令下载最新的 Jenkins WAR 文件：
```
cd $OPENSHIFT_DATA_DIR && mkdir jenkins-latest-version && cd jenkins-latest-version && wget http://mirrors.jenkins-ci.org/war/latest/jenkins.war
```
通过输入 exit 命令退出 SSH 会话。

通过运行以下命令创建两个环境变量。请将 $OPENSHIFT_DATA_DIR 替换为您 Jenkins 应用程序的 $OPENSHIFT_DATA_DIR 环境变量值：

rhc env-set JENKINS_WAR_PATH=$OPENSHIFT_DATA_DIR/jenkins-latest-version/jenkins.war JENKINS_JAR_CACHE_PATH="~/app-root/data/.jenkins/cache/jars" --app jenkins

进入 Jenkins 插件管理器，卸载 OpenShift Jenkins 插件。卸载插件后，重新启动 Jenkins 以使更改生效。您可以通过访问 https://jenkins-{domain-name}.rhcloud.com/safeRestart URL 来重新启动 Jenkins。
Jenkins 重启后，您将看到正在运行的最新版本 Jenkins，如下图所示：
与 Jenkins 最新版本不兼容的默认 OpenShift 插件无法与此版本的 Jenkins 配合使用。您需要从源代码构建最新的 OpenShift Jenkins 插件。源代码可以在 GitHub 上找到，地址为 github.com/openshift/jenkins-cloud-plugin。我已经将最新版本打包，并将其提供在 github.com/OpenShift-Cookbook/chapter10-openshift-jenkins-plugin 上。请从 github.com/OpenShift-Cookbook/chapter10-openshift-jenkins-plugin/raw/master/openshift.hpi 下载最新插件，并将其保存到您机器上的便捷位置。
通过进入插件管理器的高级选项卡并上传插件，手动安装插件。
重启 Jenkins，以便插件能够安装。
进入 Jenkins 系统配置，添加一个新的 OpenShift 云，点击保存。请查看以下截图：
进入 插件管理器（https://jenkins-{domain-name}.rhcloud.com/pluginManager/），并更新所有已安装的插件。
最后，为了测试你现有的所有任务是否正常运行，手动启动一个现有任务。如果你按照上一个步骤操作，那么你应该能在 Jenkins 仪表盘上看到三个 Jenkins 任务。

它是如何工作的……

OpenShift Jenkins 插件允许用户通过定义一个名为 JENKINS_WAR_PATH 的环境变量来升级 Jenkins 版本。如果使用了这个环境变量，OpenShift Jenkins 插件将会使用该路径下的 Jenkins war 文件。在第 1 步到第 4 步中，你首先下载了最新版本的 Jenkins WAR 文件，然后创建了 JENKINS_WAR_PATH 环境变量。

你还创建了另一个环境变量，名为 JENKINS_JAR_CACHE_PATH。这个变量在 Jenkins 版本 1.540 或更高版本中是必需的。需要设置这个环境变量的原因是，如果不设置，Jenkins 会尝试将插件缓存到用户主目录的 ~/.jenkins/cache/jars 路径下。而在 OpenShift 中，你只能向 $OPENSHIFT_DATA_DIR 目录写入数据。这个环境变量确保 JAR 文件被缓存到一个可写的目录，否则你的构建会失败。

在设置环境变量后，你重启了 Jenkins，以便让 Jenkins 识别新的环境变量。现在，你将看到运行的是最新版本的 Jenkins。

另见

将 Jenkins CI 添加到你的应用程序的步骤

第十一章：日志记录与扩展 OpenShift 应用

本章的具体操作指南如下：

查看应用日志
处理 JBoss 应用日志
启用 JBoss 访问日志
处理 Tomcat 应用日志
处理 Python 应用日志
创建可扩展的应用
为 HAProxy 配置不同的健康检查 URL
配置 HAProxy 使用不同的负载均衡算法
从不可扩展应用创建可扩展应用
使用标记文件启用手动扩展

介绍

本章包含了一些操作指南，帮助你处理应用日志并创建可扩展的应用。这些日志操作指南将帮助你访问应用日志并调试在运行应用时可能遇到的任何问题。你将学习 OpenShift 如何使用一个名为logshifter的组件，将所有应用和硬件相关的日志存储在OPENSHIFT_LOG_DIR中。本章将详细介绍应用日志，并涵盖 JBoss、Tomcat 和 Python 应用的日志管理。所涵盖的日志概念将帮助你处理任何 Web 硬件日志。

查看应用日志的操作指南将为你提供应用日志的概述，以 PHP Web 硬件为例。你将学习如何使用 rhc 命令行工具访问应用日志，并理解 Apache 基础硬件使用的日志格式。接下来，你将学习如何在处理 JBoss 应用日志和启用 JBoss 访问日志的操作指南中访问 JBoss 应用日志。处理 Python 应用日志的操作指南将涵盖如何有效地处理 Python 应用日志。

本章的第二部分将详细讨论应用扩展。你将学习如何在创建可扩展的应用的操作指南中创建自动扩展的应用。自动扩展并不总是所需的，有时你需要手动控制应用扩展。在使用标记文件启用手动扩展的操作指南中，你将学习如何禁用自动扩展，并使用 rhc 命令行工具手动扩展 OpenShift 应用。

查看应用日志

日志是由应用生成的重要数据，能帮助你理解用户行为、监控应用性能并调试问题。当应用出现故障时，日志是你首先查看的地方。OpenShift 使用一个名为 logshifter 的服务，该服务收集应用各部分的日志并将它们汇聚在一个位置，供你访问。然后，这些日志可以被发送到你喜欢的日志管理解决方案中，如 Splunk，从中获取更多有价值的洞察。在本操作指南中，你将学习如何通过一个命令轻松查看应用的所有日志。本操作指南是以与硬件无关的方式进行日志管理，特定语言的日志管理会在本章后续部分进行介绍。

准备工作

为完成此操作，你需要在你的机器上安装 rhc。此外，我们将利用在 使用 rhc 命令行客户端创建 OpenShift 应用程序 一章中创建的 OpenShift 应用程序，第三章，创建和管理应用程序。

要重新创建应用程序，请运行以下命令：

$ rhc create-app myapp php-5.4

如何执行此操作…

要查看应用程序的日志文件，执行以下步骤：

打开一个命令行终端，并运行以下命令，可以在应用程序目录内或通过使用 --app 选项传递应用程序名称来运行。请看以下命令：
```
$ rhc tail
```
你也可以使用应用程序名称，如下所示的命令：
```
$ rhc tail --app myapp
```
打开你喜欢的浏览器，访问 http://myapp-{domain-name}.rhcloud.com。你会注意到新的日志正在你的命令行终端上被实时跟踪。以下命令行输出显示了日志的一个小片段：
```
117.212.42.145 - - [22/Jun/2014:15:28:03 -0400] "GET / HTTP/1.1" 200 39627 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.153 Safari/537.36"
```

工作原理…

每个 OpenShift 应用程序都使用一个或多个 cartridge 来执行任务。每个 cartridge 都被配置为将消息记录到 stdout 或 stderr。一个名为 logshifter 的 OpenShift 服务会捕获所有发送到 stdout 和 stderr 的消息，并正确记录这些日志。在 OpenShift Online 中，logshifter 捕获的所有消息都会写入到 $OPENSHIFT_LOGS_DIR 目录。你可以使用 rhc ssh 命令通过 SSH 连接到应用程序 gear，并查看 $OPENSHIFT_LOGS_DIR 目录，示例如下：

[myapp-{domain-name}.rhcloud.com logs]\> cd $OPENSHIFT_LOG_DIR
[myapp-{domain-name}.rhcloud.com logs]\> ls
php.log

如你在前面的命令行中所见，$OPENSHIFT_LOGS_DIR 目录包含一个名为 php.log 的日志文件。所有应用程序日志和 Apache 日志（包括访问日志和错误日志）都会写入此日志文件。日志文件的名称取决于在 cartridge 启动时传递给 logshifter 的标签名称。例如，php cartridge 是使用 nohup /usr/sbin/httpd $HTTPD_CMD_CONF -D FOREGROUND |& /usr/bin/logshifter -tag php & 命令启动的。此命令确保 Apache 日志通过管道传输到 logshifter 服务，并使用 php 作为标签名称。标签名称有两个作用：首先，它标识了生成日志消息的程序；其次，它作为日志文件的名称。

在步骤 1 中，你运行了 rhc tail 命令；该命令在后台打开了一个 SSH 隧道，并在你的应用程序 gear 上运行了 tail –f */log*/* 命令。-f 选项使文件能够被持续监控。当新行被添加到日志文件时，tail 会更新显示。rhc tail 命令会跟踪你应用程序 gear 中 $OPENSHIFT_LOG_DIR 目录下的所有日志，如步骤 2 所示。以下命令显示了示例输出。所有基于 Apache 的 cartridge（如 PHP、Python、Perl 和 Ruby）都会在日志中显示类似的输出。请看以下命令输出：

117.212.42.145 - - [22/Jun/2014:15:28:03 -0400] "GET / HTTP/1.1" 200 39627 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.153 Safari/537.36"

初看起来，输出可能看起来有些晦涩；但仔细检查后，它与大多数应用程序日志没有什么不同。该日志遵循 Apache 联合日志格式（httpd.apache.org/docs/trunk/logs.html#combined）。使用的格式是"%{X-Forwarded-For}i %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"". 让我们逐一看看这些选项：

%{X-Forwarded-For}i：这是 HTTP 请求的X-Forwarded-For头。它包含原始客户端的 IP 地址。在前面的命令中显示的日志行中，它对应的值是117.212.42.145。
%l：这是由identd确定的用户身份。如果该值不存在，则返回-。在前面的命令中显示的日志行中，值为-。
%u：这是通过 HTTP 认证确定的远程用户。如果该值不存在，则返回-。在前面的命令中显示的日志行中，值为-。
%t：这是接收到 HTTP 请求的时间。在前面的命令中显示的日志行中，值为[22/Jun/2014:15:28:03 -0400]。
\"%r\"：这是 HTTP 请求的第一行。在前面的命令中显示的日志行中，值为GET / HTTP/1.1。
%>s：这是 HTTP 状态码。在前面的命令中显示的日志行中，值为200，表示请求成功。
%b：这是服务器的响应字节数。在前面的日志行中，值为39627。
\"%{Referer}i\"：这是链接到该 URL 的引用 URL。在前面的日志行中，值为-，表示该值不存在。
\"%{User-Agent}i\"：这是从 HTTP 请求头中提取的用户代理。在前面的日志行中，值为Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.153 Safari/537.36。

如前所述，logshifter将为每个 cartridge 写一个日志文件。因此，如果你将 MySQL cartridge 添加到应用程序中，logshifter将创建另一个名为mysql.log的日志文件，并将所有 MySQL 特定的日志写入该文件。rhc tail命令将查看$OPENSHIFT_LOG_DIR内的所有文件。确保重新运行tail命令，以便它可以读取新的日志文件：

==> app-root/logs/php.log <==
117.212.42.145 - - [22/Jun/2014:17:18:09 -0400] "GET / HTTP/1.1" 200 39627 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.153 Safari/537.36"
==> app-root/logs/mysql.log <==
140622 17:17:31 [Note] Event Scheduler: Loaded 0 events
140622 17:17:31 [Note] /opt/rh/mysql55/root/usr/libexec/mysqld: ready for connections.

mysql.log日志文件将包含所有 MySQL 日志。如果你只想查看特定的 cartridge 日志，可以使用rhc tail命令的-f或--files选项，如下所示。这将仅查看mysql.log文件。

$ rhc tail --files app-root/logs/mysql.log

你可以通过查看rhc tail命令的帮助来查看所有选项，如下所示：

$ rhc tail --help

另一个 logshifter 执行的任务是在日志文件达到可配置的阈值时，根据文件大小进行滚动。它还允许你在下一个滚动之前保留一定数量的滚动文件，并删除最旧的文件。你可以使用 LOGSHIFTER_$TAG_MAX_FILESIZE 和 LOGSHIFTER_$TAG_MAX_FILES 环境变量配置文件大小和滚动文件数量，其中 $TAG 是由 -tag 参数的值替换的大写字符串。logshifter 使用的默认值是 10M（M 代表兆字节）作为文件大小，10 作为滚动文件的数量。假设你希望将文件大小配置为 20M，滚动文件数量配置为 5。要配置这些新值，你必须首先使用 rhc env 命令设置新的环境变量，然后重启应用程序，如下命令所示：

$ rhc env-set LOGSHIFTER_PHP_MAX_FILES=5 LOGSHIFTER_PHP_MAX_FILESIZE=20M && rhc restart-app

你可以指定文件大小为千字节（例如 100K）、兆字节（例如 20M）、吉字节（例如 10G）或太字节（例如 2T）。文件大小的 0 值将有效地禁用文件滚动。

还有更多…

你还可以通过 --opts 或 -o 选项要求 rhc tail 命令输出最后 n 行。要输出最后 100 行，请运行以下命令：

$ rhc tail --opts "-n 100"

你也可以通过 --opts 选项传递其他 tail 命令选项。

另请参见

第三章中的 使用 rhc 命令行客户端创建 OpenShift 应用程序 食谱，创建与管理应用程序
与 JBoss 应用程序日志一起工作 这篇食谱
与 Tomcat 应用程序日志一起工作 这篇食谱
与 Python 应用程序日志一起工作 这篇食谱

与 JBoss 应用程序日志一起工作

如同在 查看应用程序日志 食谱中提到的那样，日志是应用程序生成的重要数据。本食谱将详细介绍如何在 OpenShift 的 JBoss 卡带应用程序中处理日志。本食谱将从查看现有 JBoss 应用程序的日志开始，接着你将使用 SLF4J 库添加特定于应用程序的日志记录。本食谱假设你已经阅读过 查看应用程序日志 食谱。

准备工作

本食谱将使用 使用 JBoss EAP 和 PostgreSQL 9.2 卡带创建和部署 Java EE 6 应用程序 食谱中创建的应用程序，位于第七章，Java 开发人员的 OpenShift。你可以使用以下命令重新创建应用程序：

$ rhc create-app jobstore jbosseap postgresql-9.2 --from-code https://github.com/OpenShift-Cookbook/chapter7-jobstore-javaee6.git

如何操作…

执行以下步骤：

你可以通过运行以下命令来查看 JBoss 卡带日志：
```
$ rhc tail --files */log*/jbosseap.log --app jobstore 
```

你使用 --files 选项来限制 rhc tail 命令只显示 JBoss 特定的日志，否则它将显示 $OPENSHIFT_LOG_DIR 目录中的所有日志。这将输出日志，如以下命令所示：

==> app-root/logs/jbosseap.log <==
2014/06/28 13:05:59,844 INFO  [org.jboss.web] (ServerService Thread Pool -- 65) JBAS018210: Register web context: 
2014/06/28 13:06:00,153 INFO  [org.jboss.as.server] (ServerService Thread Pool -- 36) JBAS018559: Deployed "ROOT.war" (runtime-name : "ROOT.war")

在浏览器中打开应用程序 URLhttp://jobstore-{domain-name}.rhcloud.com，你会在终端看到 Hibernate 特定的日志。当你访问应用程序根目录时，将发出一个 HTTP GET 请求以获取数据库中的所有公司。以下查询是 Hibernate 执行的 SQL 语句，用于从数据库中获取数据：
```
2014/06/28 13:42:50,423 INFO [stdout] (http-127.13.169.1/127.13.169.1:8080-1) Hibernate: select company0_.id as col_0_0_, company0_.name as col_1_0_, company0_.description as col_2_0_ from Company company0_
```

OpenShift 的 JBoss 插件被配置为将所有INFO及之前的消息记录到控制台。正如在查看应用程序日志小节中所提到的，任何写入stdout的消息都会被logshifter捕捉并写入日志文件。对于 JBoss EAP 插件，日志文件名为jbosseap.log，而对于 JBoss AS 7 插件，日志文件名为jbossas.log。你可以通过更新.openshift/config目录中的standalone.xml文件中的日志子系统来显示所有DEBUG及之前的消息，代码如下：

<subsystem >
  <console-handler name="CONSOLE">
    <level name="DEBUG" />
    <formatter>
      <pattern-formatter
        pattern="%d{yyyy/MM/dd HH:mm:ss,SSS} %-5p [%c] (%t) %s%E%n" />
    </formatter>
  </console-handler>
  <logger category="com.arjuna">
    <level name="WARN" />
  </logger>
  <logger category="org.apache.tomcat.util.modeler">
    <level name="WARN" />
  </logger>
  <logger category="sun.rmi">
    <level name="WARN" />
  </logger>
  <logger category="jacorb">
    <level name="WARN" />
  </logger>
  <logger category="jacorb.config">
    <level name="ERROR" />
  </logger>
  <root-logger>
    <level name="DEBUG" />
    <handlers>
      <handler name="CONSOLE" />
    </handlers>
  </root-logger>
</subsystem>

提交你在本地 Git 仓库中的更改，然后将其推送到 OpenShift 应用程序设备。OpenShift 现在将使用更新后的standalone.xml文件，你将在rhc tail命令的输出中看到DEBUG日志。
由于应用程序没有记录任何内容，rhc tail命令的输出显示的是应用程序服务器日志，或者是应用程序中使用的不同库的日志。你可以使用任何 Java 日志库来添加特定于应用程序的日志。在本节中，你将使用SLF4J和java.util.logging绑定来记录应用程序日志，但你也可以使用其他SLF4J绑定，如log4j或logback。打开 Maven 的pom.xml文件，并向其中添加以下依赖：
```
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>1.7.7</version>
</dependency>
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-jdk14</artifactId>
  <version>1.7.7</version>
</dependency>
```
在编辑器中打开CompanyResource.java文件，位于org.osbook.jobstore.rest包中，并添加几条语句来导入SLF4J类，如下所示的代码：
```
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
```

添加import语句后，按如下代码更新CompanyResource.java中的createNewCompany()和showAll()方法，添加日志消息：

private Logger logger = LoggerFactory.getLogger(CompanyResource.class);
@Inject
private CompanyService companyService;

@POST
@Consumes(MediaType.APPLICATION_JSON)
public Response createNewCompany(@Valid Company company) {
  logger.debug("inside createNewCompany().. creating new company {}" , company);
  Company existingCompanyWithName = companyService.findByName(company.getName());
  if (existingCompanyWithName != null) {
    logger.debug("Company with name {} already exists : {}" , company.getName(), existingCompanyWithName);
    return Response.status(Status.NOT_ACCEPTABLE)
            .entity(String.format("Company already exists with name: %s",company.getName())).build();
    }
  company = companyService.save(company);
  logger.info("Created new company {}" , company);
  return Response.status(Status.CREATED).entity(company).build();
}

@GET
@Produces(MediaType.APPLICATION_JSON)
public List<Company> showAll() {
  List<Company> companies = companyService.findAll();
  logger.info("Found {} companies" , companies.size());
  return companies;
}

撤销你在步骤 3 中对standalone.xml文件所做的更改，以便仅查看INFO级别的消息。将root-logger的级别更改为INFO，如下所示的代码：
```
<root-logger>
  <level name="INFO" />
  <handlers>
    <handler name="CONSOLE" />
  </handlers>
</root-logger>
```
提交对本地 Git 仓库的更改，然后使用git push命令将其推送到应用程序设备。
更改部署后，再次向 Web 应用程序发出请求，这时你将在rhc tail命令的输出中看到应用程序日志，如下所示：
```
2014/06/28 14:24:50,959 INFO  [org.osbook.jobstore.rest.CompanyResource] (http-127.13.169.1/127.13.169.1:8080-1) Found 1 companies
```
如果你尝试创建一个新公司，你会发现只有INFO级别的消息被记录。这是因为standalone.xml文件中的日志配置被设置为仅将INFO及之前的消息记录到控制台。

要查看应用程序的调试消息，你需要按照如下代码更新standalone.xml日志子系统配置：

<subsystem >
  <console-handler name="CONSOLE">
    <level name="DEBUG" />
    <formatter>
      <pattern-formatter
        pattern="%d{yyyy/MM/dd HH:mm:ss,SSS} %-5p [%c] (%t) %s%E%n" />
    </formatter>
  </console-handler>
  <logger category="com.arjuna">
    <level name="WARN" />
  </logger>
  <logger category="org.apache.tomcat.util.modeler">
    <level name="WARN" />
  </logger>
  <logger category="sun.rmi">
    <level name="WARN" />
  </logger>
  <logger category="jacorb">
    <level name="WARN" />
  </logger>
  <logger category="jacorb.config">
    <level name="ERROR" />
  </logger>
  <logger category="org.osbook.jobstore">
    <level name="DEBUG"></level>
  </logger>
  <root-logger>
    <level name="INFO" />
    <handlers>
      <handler name="CONSOLE" />
    </handlers>
  </root-logger>
</subsystem>

现在，您还将在rhc tail命令的输出中看到特定于应用程序的DEBUG日志：

2014/06/28 14:40:22,410 DEBUG [org.osbook.jobstore.rest.CompanyResource] (http-/127.13.169.1:8080-1) inside createNewCompany().. creating new company

它是如何工作的…

在前面的步骤中，您学习了如何查看 JBoss 应用程序的日志，并使用SLF4J库添加特定于应用程序的日志记录。在第 1 步中，您运行了rhc tail命令以查看所有 JBoss 特定的日志。所有 JBoss EAP 特定的日志都写入jbosseap.log文件。此文件包含 JBoss 的server.log和boot.log内容。如在查看应用程序日志一节中所述，logshifter将收集所有写入stdout或stderr的日志，并将它们写入特定于应用程序的日志文件。通过在standalone.xml配置文件中配置日志子系统，可以控制 JBoss 卡带中的日志记录。standalone.xml文件位于.openshift/config目录内，您可以覆盖该文件以满足您的需求。日志子系统由三部分组成：一个或多个处理程序配置，例如console-handle或file-handler，一个或多个日志记录器用于定义日志类别，例如下一个代码中所示的com.arjuna，以及一个root-logger声明。您可以在官方文档中了解更多关于 JBoss 日志配置的内容，网址为docs.jboss.org/author/display/AS71/Logging+Configuration。请看下面的代码：

<subsystem >
  <console-handler name="CONSOLE">
    <level name="DEBUG" />
    <formatter>
      <pattern-formatter
        pattern="%d{yyyy/MM/dd HH:mm:ss,SSS} %-5p [%c] (%t) %s%E%n" />
    </formatter>
  </console-handler>
  <logger category="com.arjuna">
    <level name="WARN" />
  </logger>
  <root-logger>
    <level name="DEBUG" />
    <handlers>
      <handler name="CONSOLE" />
    </handlers>
  </root-logger>
</subsystem>

在第 3 步中，您将root-logger级别更新为DEBUG。这使得 JBoss 服务器能够生成DEBUG及其之前级别的日志。

从第 5 步到第 11 步，您首先使用SLF4J库添加了应用程序日志，然后更新了standalone.xml的日志子系统配置，以便 JBoss 记录应用程序的DEBUG以及前面的消息。此操作是通过在DEBUG级别添加特定于应用程序的logger category来完成的。请看下面的代码：

  <logger category="org.osbook.jobstore">
    <level name="DEBUG"></level>
  </logger>

还有更多…

阅读完此部分内容后，您可能会想知道是否有办法在运行时更新日志配置。是的，您可以使用 JBoss 管理员控制台来做到这一点。要使用 JBoss 管理员控制台，首先运行rhc port-forward命令，如下所示：

$ rhc port-forward --app jobstore

然后，进入管理员控制台，网址为http://127.0.0.1:9990/。导航到配置 | 核心 | 日志记录，如下图所示：

现在，转到日志类别，您将看到一个org.osbook.jobstore的类别，如下图所示：

将日志级别的值更改为INFO，然后点击保存按钮：

现在，如果您尝试创建一个新公司，您将不会看到DEBUG消息。您只会看到INFO和前面的消息。

另见

查看应用程序日志 这部分内容
启用 JBoss 访问日志 这部分内容

启用 JBoss 访问日志

访问日志在你希望查看服务器处理的所有请求时非常有用。对于基于 Apache 的 Cartridges，默认情况下会启用访问日志，但在基于 JBoss 的 Cartridges 中，你需要手动启用它。在本配方中，你将学习如何为 JBoss Cartridges 启用访问日志。

准备工作

本配方将从我们在使用 JBoss 应用程序日志配方中所讲的内容继续。

如何操作…

执行以下步骤以启用访问日志：

在你喜欢的编辑器中打开位于.openshift/config目录下的standalone.xml文件。

使用以下代码更新urn:jboss:domain:web:1.5子系统：

<subsystem 
  default-virtual-server="default-host" native="false">
  <connector name="http" protocol="HTTP/1.1" scheme="http"
    socket-binding="http" />
  <virtual-server name="default-host" enable-welcome-root="false">
    <alias name="localhost" />
    <access-log pattern="%a %t %H %p %U %s %S %T" rotate="true">
      <directory path="app-root/logs/" relative-to="user.home" />
    </access-log>
  </virtual-server>
  <valve name="remoteipvalve" module="org.jboss.as.web"
    class-name="org.apache.catalina.valves.RemoteIpValve">
    <param param-name="protocolHeader" param-value="x-forwarded-proto" />
  </valve>
</subsystem>

将更改提交到本地 Git 仓库，然后使用git push命令将更改推送到应用程序的 gear 中。

再次运行rhc tail命令，你将在tail命令的输出中看到访问日志，如下所示：

==> app-root/logs/access_log.2014-06-28 <==
106.211.32.170 [28/Jun/2014:15:43:28 -0400] HTTP/1.1 80 /api/v1/companies 200 - 5.409

它是如何工作的…

访问日志存储了所有用户请求的单独资源。这些请求包括获取 HTML 文件、JavaScript 文件、CSS 文件、REST 调用等。存储在该文件中的数据可以由其他应用程序进行分析，从中提取有意义的信息。访问日志可以帮助你：

它有助于计算你网站的独立访客数量。
它有助于计算成功请求和失败请求的数量。2XX代码的请求视为成功，4xx和5xx代码的请求视为错误。
它有助于进行基本的性能分析。每一行访问日志都包含了处理请求所花费的时间。
它有助于分析你的网站应用程序使用模式，如一天中的时间、星期几等。

在前面的步骤中，你更新了urn:jboss:domain:web:1.5子系统配置以启用访问日志。将以下两行添加到配置中可启用访问日志：

<access-log pattern="%a %t %H %p %U %s %S %T" rotate="true">
<directory path="app-root/logs/" relative-to="user.home" />

access-log元素启用访问日志，而directory元素用于指定生成日志的目录。前述的directory元素配置了 JBoss 将访问日志写入$OPENSHIFT_LOG_DIR，因为它查找相对于用户主目录的app-root/logs目录。app-root/logs目录相对于用户主目录为$OPENSHIFT_LOG_DIR。我们使用了这个值，以便rhc tail命令可以读取该文件以及其他 JBoss 日志。access-log元素需要一个名为pattern的必选属性。pattern元素定义日志的格式。以下是支持的模式代码：

%a：远程 IP 地址
%A：本地 IP 地址
%b：发送的字节数，不包括 HTTP 头部，如果为零，则显示-
%B：发送的字节数，不包括 HTTP 头部
%h：远程主机名（如果resolveHosts为false，则为 IP 地址）
%H：请求协议
%l：来自identd的远程逻辑用户名（始终返回-）
%m：请求方法（如 GET、POST 等）
%p：接收此请求的本地端口
%q：查询字符串（如果存在，前面加上?）
%r：请求的第一行（方法和请求 URI）
%s：响应的 HTTP 状态码
%S：用户会话 ID
%t：以通用日志格式显示的日期和时间
%u：经过身份验证的远程用户（如果有），否则为-
%U：请求的 URL 路径
%v：本地服务器名称
%D：处理请求所花费的时间（以毫秒为单位）
%T：处理请求所花费的时间（以秒为单位）
%I：当前请求线程的名称（可以稍后与堆栈跟踪进行比较）

另见

处理 JBoss 应用程序日志食谱
查看应用程序日志食谱

处理 Tomcat 应用程序日志

在此食谱中，你将学习如何处理 Tomcat 应用程序中的日志。你将首先学会跟踪现有 Tomcat 应用程序的日志，然后学习如何使用SLF4J库添加特定于应用程序的日志记录。

准备工作

本食谱将使用在第七章的使用 Tomcat 7 启动和部署 Spring 应用程序食谱中创建的应用程序。你可以使用以下命令重新创建该应用程序：

$ rhc create-app jobstore tomcat-7 mysql-5.5 --from-code https://github.com/OpenShift-Cookbook/chapter7-jobstore-spring.git --timeout 180

如何执行……

执行以下步骤：

你可以使用rhc tail命令查看 Tomcat 应用程序的日志。Tomcat 日志写入名为jbossews.log的文件，该文件位于$OPENSHIFT_LOG_DIR目录下：
```
$ rhc tail --files */log*/jbossews.log --app jobstore
```

jbossews.log文件将包含 Tomcat 特定的日志和特定于应用程序的日志，如下所示：

INFO: Starting ProtocolHandler ["http-bio-127.5.249.129-8080"]
Jun 29, 2014 5:03:01 AM org.apache.catalina.startup.Catalina start
INFO: Server startup in 22062 ms

在添加特定于应用程序的日志记录之前，你需要在 Maven 的pom.xml文件中添加以下依赖项。在此食谱中，你将使用SLF4J与logback绑定来添加应用程序日志记录：

<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>1.7.7</version>
</dependency>
<dependency>
  <groupId>ch.qos.logback</groupId>
  <artifactId>logback-classic</artifactId>
  <version>1.0.13</version>
</dependency>

在编辑器中打开org.osbook.jobstore.rest包中的CompanyResource.java文件，并添加几行代码以导入SLF4J类，如下所示：
```
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
```

现在，更新org.jobstore.rest包下的CompanyResource Java 类，以添加特定于应用程序的日志记录，如下所示：

private Logger logger = LoggerFactory.getLogger(CompanyResource.class);

@RequestMapping(method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<Company> createNewCompany(@RequestBody Company company) {
  logger.debug("inside createNewCompany().. creating new company {}" , company);
  Company existingCompany = companyRepository.findByName(company.getName());
  if(existingCompany != null){
    logger.debug("Company with name {} already exists : {}" , company.getName(), existingCompany);
    return new ResponseEntity<>(HttpStatus.NOT_ACCEPTABLE);
  }
  company = companyRepository.save(company);
  logger.info("Created new company {}" , company);
  return new ResponseEntity<>(company,HttpStatus.CREATED);
}

@RequestMapping(method=RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public @ResponseBody List<Company> showAll(){
  List<Company> companies = companyRepository.findAll();
  logger.info("Found {} companies" , companies.size());
  return companies;
}

提交更改到本地 Git 仓库，然后使用git push命令将它们推送到应用程序服务器。

应用程序重启后，你将开始看到各种日志消息。以下输出显示了一个简短的日志片段：

05:43:00.182 [http-bio-127.5.249.129-8080-exec-6] INFO  org.jobstore.rest.CompanyResource - Created new company Company [id=1, name=Red Hat, description=open source company, contactEmail=contact@redhat.com]
05:43:00.245 [http-bio-127.5.249.129-8080-exec-6] DEBUG o.s.w.s.m.m.a.HttpEntityMethodProcessor - Written [Company [id=1, name=Red Hat, description=open source company, contactEmail=contact@redhat.com]] as "application/json" using [org.springframework.http.converter.json.MappingJackson2HttpMessageConverter@1d300d2]

你可以使用logback配置文件来启用特定包的日志记录。在src/main/resources目录下创建一个名为logback.xml的新文件，并添加以下内容：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
       <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
		<encoder>
			<pattern>%d %5p %C:%4L - %m%n</pattern>
		</encoder>
	</appender>
	<logger name="org.jobstore" level="debug" />
	<root level="WARN">
		<appender-ref ref="console" />
	</root>
</configuration>

提交更改到本地 Git 仓库，并使用git push命令将它们推送到应用程序服务器。应用程序重启后，你将只看到特定于应用程序的DEBUG消息和前面的消息。请查看以下命令：

INFO: Server startup in 49113 ms
2014-06-29 06:07:27,817  INFO org.jobstore.rest.CompanyResource:  45 - Found 1 companies
2014-06-29 06:07:38,513 DEBUG org.jobstore.rest.CompanyResource:  31 - inside createNewCompany().. creating new company Company [id=null, name=test, description=test, contactEmail=test@test.com]
2014-06-29 06:07:38,752  INFO org.jobstore.rest.CompanyResource:  38 - Created new company Company [id=2, name=test, description=test, contactEmail=test@test.com]

它是如何工作的……

在上述步骤中，你学习了如何查看 Tomcat 应用程序的日志，并使用 SLF4J 库添加应用程序特定的日志记录。在第 1 步中，你运行了 rhc tail 命令以查看所有 Tomcat 特定的日志。所有 Tomcat 特定的日志都写入到 jbossews.log 文件中。如 查看应用程序日志 配方中所讨论的，logshifter 将收集所有写入到 stdout 或 stderr 的日志，并将它们写入到载体特定的日志文件中。

从第 2 步到第 5 步，你使用 SLF4J 库向 CompanyResource.java 文件添加了日志语句。 SLF4J 库底层使用具有默认日志级别 DEBUG 的 Logback 库。这意味着如果你没有指定任何 Logback 配置，那么所有的 DEBUG 及其前面的消息将被记录到 jbossews.log。

使用 logback.xml 文件可以配置 Logback。在第 6 步中，你创建了一个 logback.xml 文件，并仅添加了对日志应用程序 DEBUG 消息的配置。所有其他消息将以 WARN 级别记录。最后，在第 7 步中，你提交了更改并将它们推送到应用程序装置。

还有更多内容…

你可以通过执行以下步骤为 Tomcat 载体启用访问日志：

打开位于 .openshift/config 目录中的 Tomcat server.xml 配置文件。

将 AccessLogValve 配置添加到 server.xml 文件的 Host 元素中：

<Valve className="org.apache.catalina.valves.AccessLogValve" directory="${user.home}/app-root/logs" prefix="localhost_access_log." suffix=".txt" pattern="%h %l %u %t &quot;%r&quot; %s %b"/>

将更改提交到本地 Git 仓库，并使用 git push 命令将它们推送到应用程序装置。

再次运行 rhc tail 命令，这次你将看到访问日志，如下所示：

==> app-root/logs/localhost_access_log.2014-06-29.txt <==
127.5.249.129 - - [29/Jun/2014:07:18:57 -0400] "POST /api/v1/companies HTTP/1.1" 201 133
127.5.249.129 - - [29/Jun/2014:07:18:58 -0400] "GET /api/v1/companies HTTP/1.1" 200 344

另请参阅

查看应用程序日志 配方
使用 JBoss 应用程序日志 配方
启用 JBoss 访问日志 配方

处理 Python 应用程序日志

在这个配方中，你将学习如何为你的 Python 应用程序添加视图和日志记录。如第八章讨论的，OpenShift for Python Developers，OpenShift Python 应用程序使用带有 mod_wsgi 的 Apache。

准备就绪

本配方将使用在第八章中创建并部署 Flask Web 应用程序使用 Python 和 PostgreSQL 载体配方中创建的应用程序。你可以使用以下命令重新创建应用程序：

$ rhc create-app jobstore python-2.7 postgresql-9.2 --from-code https://github.com/OpenShift-Cookbook/chapter8-jobstore-python-flask.git

如何操作…

执行以下步骤：

打开新的命令行终端，并导航到创建 Python 应用程序的目录。
要查看 Python 应用程序的日志，请运行以下命令：
```
$ rhc tail --files */log*/python.log
```

通过访问应用程序的 URL，当你向应用程序发出请求时，你将在 rhc tail 命令的输出中看到以下日志：

117.207.184.93 - - [29/Jun/2014:14:50:09 -0400] "GET /api/v1/companies HTTP/1.1" 200 17 "http://jobstore-osbook.rhcloud.com/" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.153 Safari/537.36"

打开应用程序目录中的jobstore.py文件，并在index()函数上方添加以下代码。以下代码导入了logging模块，然后创建了一个新的logger对象，日志级别为INFO。此logger将在下一步用于日志记录。
```
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
```

接下来，更新index()函数，添加一个日志语句，如以下代码所示：

@app.route('/')
def index():
logger.info('inside index()...')
return render_template('index.html')

提交更改到本地 Git 仓库，然后将更改推送到应用程序设备。应用程序成功启动后，访问应用程序 URL，你将看到你添加到jobstore.py中的日志消息，如下所示：
```
[Sun Jun 29 14:56:08 2014] [error] INFO:jobstore:inside index()...
```

有时，你可能更倾向于使用不同的文件来存储应用程序日志。这可以通过使用TimedRotatingFileHandler来完成。打开应用程序根目录中的jobstore.py文件，并用以下代码替换第 3 步中添加的日志行：

import logging
import logging.handlers
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
log_location = os.environ.get('OPENSHIFT_LOG_DIR') if os.environ.get('OPENSHIFT_LOG_DIR') else '/tmp/'
log_filename = log_location + 'jobstore.log'
handler = logging.handlers.TimedRotatingFileHandler(log_filename,when='midnight',backupCount=5)
handler.setFormatter(formatter)
logger.addHandler(handler)

提交更改并将更改推送到应用程序设备。应用程序重启后，你将看到一个新的文件jobstore.log，其中包含所有应用程序特定的日志，如以下命令所示。你必须运行rhc tail命令，以便tail命令能够找到新文件，具体如下：
```
==> app-root/logs/jobstore.log <==
2014-06-29 15:25:34,158 - jobstore - INFO - inside index()...
```

它是如何工作的……

Python 应用程序日志记录在$OPENSHIFT_LOG_DIR中的python.log文件中。此文件将包含 Apache 访问日志和错误日志，以及任何应用程序特定的日志。日志遵循在查看应用程序日志一节中讨论的 Apache 联合日志格式。

为了添加应用程序级别的日志记录，你在第 3 步中使用了 Python 标准日志模块。在将这些更改推送到应用程序设备后，你将开始看到特定应用程序的日志消息。你只会看到INFO级别或更高级别的日志消息。这是因为你已将默认的日志级别配置为logging.INFO。

OpenShift 默认会将所有写入stdout或stderr的消息记录到python.log文件中。如果你想为特定应用使用不同的日志文件，可以使用TimedRotaingFileHandler将消息记录到$OPENSHIFT_LOG_DIR中的jobstore.log文件，如第 5 步所示。在第 6 步，你将更改推送到 OpenShift 应用程序的设备后，再次运行rhc tail命令，你将看到输出中开始显示写入jobstore.log的消息。

另见

查看应用程序日志一节

创建可扩展的应用程序

随着应用程序变得越来越流行，更多的用户开始使用它，你将需要扩展应用程序以满足日益增加的使用量。应用程序的扩展可以通过以下两种方式之一完成：垂直扩展（或向上扩展）和水平扩展（向外扩展）。垂直扩展是指向单台机器添加更多的计算能力，即更快的 CPU、更多的内存和 SSD 等等。垂直扩展有其限制，并且成本呈指数增长。另一方面，水平扩展则是通过增加更多机器来处理更多的请求和负载。

对于大多数 PaaS 解决方案，例如 OpenShift，你很快会遇到垂直扩展的限制。目前，在 OpenShift 中，你无法获得超过 2GB 内存（即大型 gear）的 gear 大小，因此建议你设计应用程序以支持水平扩展。有很多关于这个主题的好书，例如Scalability Rules、Martin L. Abbott and Michael T. Fisher、Addison-Wesley Professional，你可以参考这些书籍获取更多信息。我还写了一篇关于创建可扩展 Web 应用程序的最佳实践文章（www.openshift.com/blogs/best-practices-for-horizontal-application-scaling），你也可以参考。

在本配方中，你将学习如何在 OpenShift 中创建可扩展的应用程序。

准备工作

要完成此配方，你需要在机器上安装rhc。此配方将需要所有三个可用的 gear，因此请确保删除任何现有的应用程序。

如何做到…

要创建一个可扩展的应用程序，请执行以下步骤：

打开命令行终端，并将目录更改为你希望创建应用程序的位置。

接下来，执行以下命令以创建可扩展应用程序：

$ rhc create-app jobstore jbosseap postgresql-9 --scaling --from-code https://github.com/OpenShift-Cookbook/chapter7-jobstore-javaee6.git

它是如何工作的…

前述步骤中使用的rhc create-app命令指示 OpenShift 创建一个名为jobstore的应用程序，并使用 JBoss EAP 和 PostgreSQL 9.2 的插件。--scaling选项告诉 OpenShift 创建一个可水平扩展的应用程序，而不是一个不可扩展的应用程序。--from-code选项告诉 OpenShift 使用指定的 Git 仓库作为参考应用程序。你也可以使用-s代替--scaling，-s选项是--scaling选项的简写。

此命令将创建两个 OpenShift gears。HAProxy 负载均衡器和 JBoss EAP 应用程序服务器将共享第一个 gear，PostgreSQL 数据库将使用第二个 gear。安装了 HAProxy 插件的 gear 称为main gear。所有针对 gear 的命令都将应用于此 gear。例如，当你运行rhc ssh命令时，你将登录到 HAProxy gear。同样，rhc tail命令将实时查看该 gear 中app-root/logs目录下的日志。

HAProxy 是一个基于软件的负载均衡器，它位于你的 Web 应用程序前端，接受所有传入请求。然后，它解析 HTTP 请求，并根据其配置，将传入请求路由到一个后端。这里的后端指的是一个或多个 JBoss EAP 实例。OpenShift 通过在并发 HTTP 连接数达到阈值时添加新的应用实例（在我们的例子中为 JBoss EAP 实例），来帮助你扩展应用程序。当前的阈值是 16 个并发 HTTP 连接。这种行为叫做自动扩展，因为 OpenShift 在无需用户干预的情况下管理应用程序扩展。你也可以配置应用程序使用手动扩展，这将让你对应用程序扩展有更多控制。具体内容将在 通过标记文件启用手动扩展 配方中讲解。

OpenShift 目前不支持数据库扩展。你可以使用 Amazon RDS 等服务（在第四章的 使用 Amazon RDS MySQL 数据库实例与 OpenShift 配方中有讲解，使用 MySQL 与 OpenShift 应用程序），Enterprise DB PostgreSQL 云数据库（在第五章的 使用 EnterpriseDB PostgreSQL 云数据库与 OpenShift 配方中有讲解，使用 PostgreSQL 与 OpenShift 应用程序），或者 MongoLab（在第六章的 使用 MongoLab MongoDB 作为服务与 OpenShift 配方中有讲解，使用 MongoDB 和第三方数据库插件与 OpenShift 应用程序）来实现数据库扩展。

每个 OpenShift 可扩展应用程序都有一个名为 haproxy_ctld 的守护进程在运行。该守护进程通过每五秒轮询 HAProxy Unix 套接字状态端口来收集基本的 HAProxy 统计信息，从而控制自动扩展行为。默认情况下，它配置为使用 HTTP 并发连接进行自动扩展，但用户可以自定义应用程序的自动扩展方式，基于其他因素，如 CPU 使用率等，进行扩展，详情请见(www.openshift.com/blogs/customizing-autoscale-functionality-in-openshift)。

守护进程检查当前的并发 HTTP 连接，如果并发连接数超过分配数的 90%，即超过 16，它将触发扩展事件。当扩展事件发生时，守护进程将向 OpenShift 代理发送 HTTP 请求，以向应用程序添加新的 Gear。代理将启动一个与现有应用程序 Gear 配置相同的新 Gear，将新 Gear 与 HAProxy 关联，使用rsync命令将主 Gear 上 ~/app-root/repo 目录的内容复制到新 Gear，然后启动新 Gear。从现在起，HAProxy 将根据配置的算法开始向两个 Gear 发送请求。默认情况下，OpenShift 使用粘性会话和最小连接平衡算法，确保来自同一用户的请求始终到达相同的 Gear，且最少连接的服务器将接收到来自新客户端的请求。用户可以根据需要覆盖默认的 HAProxy 配置。我们将在本章后面讲解这一部分。

当应用程序的 Web 流量降到分配的 HTTP 连接数的 50% 以下，并持续几分钟时，应用程序将缩减规模。然后，新 Gear 将被移除，并且它也会从 HAProxy 配置中移除。

OpenShift 应用程序开发者可以在 HAProxy 状态页面上查看 HAProxy 的统计信息。此页面位于 http://jobstore-{domain-name}.rhcloud.com/haproxy-status，如下图所示：

HAProxy 状态页面分为两部分：统计和简易。统计部分配置为监听所有访问 HAProxy 状态页面的请求。每次你刷新 http://jobstore-domainname.rhcloud.com/haproxy-status 页面时，会话选项卡下的会话总数将增加。这一数字显示在总计列下。当前列是当前正在访问状态页面的用户数量。最大列是最大并发用户数。所有这些数字是从 HAProxy 启动以来计算的；如果重新启动 HAProxy，统计数据将会重置。

简易部分从应用程序的角度来看更为有趣。local-gear 行对应 JBoss EAP 处理的请求。应用程序处理的会话总数显示在总计列下。当前列是当前正在访问应用程序的用户数。最大列是最大并发用户数。所有这些数据都与 HAProxy 启动后的时间段相关；如果重新启动 HAProxy，统计数据将会重置。在前面的截图中，我们可以看到local-gear已处理了七个请求，每次一个。当应用程序扩展时，会为新 Gear 添加更多的行。

还有更多…

您可以为应用程序的扩展定义最小值和最大值。默认情况下，可扩展应用程序至少会消耗一个组件，并且在流量峰值时，可以消耗您 OpenShift 帐户中的所有组件。您可以使用 rhc scale-cartridge 命令设置最小值和最大值，如以下命令所示：

$ rhc scale-cartridge <web cartridge> --app <app_name> --min <minimum gears> --max <maximum gear>

让我们看以下示例：

$ rhc scale-cartridge jbosseap --app jobstore --min 2 --max 4

前面的命令将确保 jobstore 应用程序至少有两个 JBoss EAP 插件实例，最多四个实例。

另请参见

配置 HAProxy 使用不同的健康检查 URL 食谱
配置 HAProxy 使用不同的负载均衡算法 食谱
启用手动缩放和标记文件 食谱

配置 HAProxy 使用不同的健康检查 URL

在本食谱中，您将学习如何更新 HAProxy 配置文件，以配置不同的健康检查 URL。

准备工作

要完成本食谱，您需要在您的计算机上安装 rhc。本食谱将使用 创建可扩展应用程序 食谱中创建的应用程序。

如何操作……

执行以下步骤：

打开命令行终端，并导航到在创建可扩展应用程序食谱中创建的应用程序目录。
使用 rhc ssh 命令 SSH 连接到主应用程序组件，如下所示：
```
$ rhc ssh --app jobstore
```
将目录更改为 haproxy 配置目录，如下所示：
```
$ cd haproxy/conf
```
现在，使用 VIM 打开 haproxy.cfg 文件，并删除以下内容：
```
option httpchk GET /
```
将以下内容插入其位置：
```
option httpchk GET /api/v1/ping
```
最后，使用 rhc 命令行客户端从本地计算机重新启动 HAProxy 插件：
```
$ rhc restart-cartridge --cartridge haproxy --app jobstore
```

它是如何工作的……

HAProxy 执行定期健康检查，以确定应用程序组件的健康状况。默认配置每两秒钟对根 URL / 进行一次 ping 操作。如果 HAProxy 收到 2xx 或 3xx 以外的 HTTP 代码，则认为是服务器故障，您的应用程序将出现 服务不可用 错误。一个常见的场景是，当您使用 OpenShift 托管 REST 后端并使用非根 URL（例如 /api/v1/）时，您将看到这种行为。在前面的步骤中，您已更新了 haproxy.cfg 文件，以使用不同的健康检查 URL。

另请参见

配置 HAProxy 使用不同的负载均衡算法 食谱
启用手动缩放和标记文件 食谱

配置 HAProxy 使用不同的负载均衡算法

HAProxy 负载均衡器可以与多种负载均衡算法一起使用。OpenShift 应用程序中使用的 HAProxy 配置使用 leastconn 负载均衡算法。当您有长期连接时，这个算法非常有用，但对于短连接并不推荐。对于短连接，如我们的应用程序，使用 roundrobin 算法更为合适。

在本食谱中，您将学习如何配置 HAProxy 使用 roundrobin 负载均衡 算法，而不是 leastconn 算法。

准备工作

为了完成这个教程，你的机器上需要安装rhc。本教程将利用在创建可扩展应用程序教程中创建的应用程序。

如何操作…

执行以下步骤将 HAProxy 配置为使用轮询（roundrobin）负载均衡算法：

打开命令行终端，并导航到在创建可扩展应用程序教程中创建的应用程序目录。
通过运行以下命令，将 JBoss EAP cartridge 扩展为使用两个 JBoss EAP 实例：
```
$ rhc scale-cartridge --min 2 --cartridge jbosseap-6
```
使用rhc ssh命令通过 SSH 登录到主应用程序 gear，如下所示：
```
$ rhc ssh --app jobstore
```
进入应用程序 gear 后，切换到haproxy/conf目录，如下所示：
```
$ cd haproxy/conf
```
在对配置文件进行任何更改之前，备份配置文件总是一个好主意。使用copy命令在$OPENSHIFT_DATA_DIR中创建haproxy.cfg文件的副本，如下所示：
```
$ cp haproxy.cfg $OPENSHIFT_DATA_DIR
```

现在，使用 VIM 打开haproxy.cfg文件，并将balance leastconn下的部分更新为以下代码：

balance roundrobin
    server gear-2 host2:port2 check fall 2 rise 3 inter 2000 weight 1
    server local-gear host1:port1 check fall 2 rise 3 inter 2000 weight 1

将gear-2替换为你应用程序的第二个 gear 名称。同时，将host1和host2、port1和port2替换为 gear 1 和 gear 2 的主机名和端口值。你可以从第 5 步中保存的haproxy.cfg副本中获取这些值。
你可以通过运行以下命令要求 HAProxy 重新加载配置：
```
$ rhc reload-cartridge --cartridge haproxy
```

运行 Apache Benchmark 以查看新配置的效果，如下所示：

$ ab -n 1000 -c 20 http://jobstore-{domain-name}.rhcloud.com/api/v1/companies

在前面的测试中，ab将总共发起1000个请求，每次20个并发请求。由于我们使用的是轮询算法，两个 gear 应该各自处理 500 个请求。你可以通过查看以下 HAProxy 状态页面（截图）来验证请求的数量：

如何运作…

HAProxy 支持多种负载均衡算法。你选择的算法将决定使用哪个后端服务器来处理请求。OpenShift 的可扩展应用程序使用的默认负载均衡算法是 leastconn。此算法选择连接数最少的服务器。HAProxy 还配置为使用持久性 cookie 来实现粘性会话行为。会话粘性确保用户的请求总是由第一个处理该请求的 gear 来处理。

在前面的步骤中，你覆盖了默认配置，使用了轮询算法。可以通过balance参数设置使用的负载均衡算法。轮询算法依次选择服务器，以确保请求公平地分配。你可以为服务器分配权重，以操控某个服务器相对于其他服务器被选择的频率。在第 6 步中，你将roundrobin作为负载均衡参数的值，并为两个服务器分配了1的权重。由于给两个服务器分配了相同的权重，两个服务器将处理相同数量的请求。然后，在第 7 步中，你使用rhc reload-cartridge命令要求 HAProxy 重新加载配置。

在步骤 8 中，你使用 Apache Benchmark 对应用程序进行了负载测试，以查看你的更改是否按预期工作。因为两个服务器的权重都是 1，它们各自处理了 500 个请求。

现在，让我们更新 HAProxy 配置，使用不同的权重分配给不同的服务器。通过以下代码更新 haproxy.cfg 的轮询部分：

balance roundrobin
    server gear-2 host2:port2 check fall 2 rise 3 inter 2000 weight 1
    server local-gear host1:port1 check fall 2 rise 3 inter 2000 weight 2

再次通过运行 rhc reload-cartridge 命令重新加载配置，然后运行在步骤 8 中执行的 Apache Benchmark 测试。因为 gear-2 的权重是 1，而 gear-1 的权重是 2，所以 gear 1 将处理比 gear 2 多一倍的请求。你可以通过查看以下 HAProxy 状态页面（截图）来验证这一点：

另见

为 HAProxy 配置不同的健康检查 URL 配方
使用标记文件启用手动扩展 配方

从不可扩展应用程序创建可扩展应用程序

OpenShift 当前不支持将现有的不可扩展应用程序转换为可扩展应用程序。在这个配方中，你将学习如何使用现有的不可扩展应用程序创建一个新的可扩展应用程序。

准备工作

要完成这个配方，你需要在你的机器上安装 rhc。这个配方需要所有三个可用的设备，因此请确保删除任何现有的应用程序。

如何操作…

执行以下步骤将不可扩展的应用程序转换为可扩展应用程序：

打开一个新的命令行终端，导航到你希望创建应用程序的便捷位置。

使用以下命令创建一个不可扩展的应用程序，使用 JBoss EAP 6：

$ rhc create-app jobstore jbosseap postgresql-9.2 --from-code https://github.com/OpenShift-Cookbook/chapter7-jobstore-javaee6.git

要使用步骤 2 中创建的应用程序创建一个可扩展的应用程序，请运行以下命令：
```
$ rhc create-app jobstorescalable --from-app jobstore --scaling
```

它是如何工作的…

使用另一个应用程序作为模板，你可以使用 --from-app 选项创建一个新的应用程序。当你指定 --from-app 选项时，OpenShift 将使用模板应用程序的配置来创建新应用程序。该配置包括现有的插件、存储配置、设备大小、扩展配置、部署配置等。

在之前的步骤中，你已经将一个不可扩展的应用程序转换为可扩展的应用程序。因为你想创建一个可扩展的应用程序，所以必须提供 --scaling 选项；否则，将会创建一个不可扩展的应用程序。你还可以使用 --gear-size 选项指定不同的设备大小：

$ rhc create-app jobstorescalable --from-app jobstore –-scaling --gear-size large

除了 --scaling 和 --gear-size 选项外，你还可以提供 --env、--no-git 和 --enable-jenkins 选项。

--from-app 选项利用应用程序快照来传输模板应用程序的数据和 Git 仓库。它首先获取 jobstore 应用程序的快照，将其传输到 jobstorescalable 应用程序，然后恢复该快照。在以下命令行中可以看到应用程序创建的日志：

Setting deployment configuration ... done
Pulling down a snapshot of application 'jobstore' to /var/folders/9s/kp39j6zj1wg90n4jwshtdykh0000gn/T/jobstore_temp_clone.tar.gz
...
done
Restoring from snapshot /var/folders/9s/kp39j6zj1wg90n4jwshtdykh0000gn/T/jobstore_temp_clone.tar.gz to application
'jobstorescalable' ...
done

注意

使用 --from-app 创建应用程序时，卡带数据不会被传输，但存储在 $OPENSHIFT_DATA_DIR 中的任何数据都会被传输到新应用程序。

另见

创建可扩展应用程序 配方
使用标记文件启用手动扩展 配方

使用标记文件启用手动扩展

在此配方中，你将学习如何使用 rhc 命令行工具禁用自动扩展并手动添加齿轮到可扩展应用程序。

准备就绪

要完成此配方，你的机器上需要安装 rhc。此配方将使用在 创建可扩展应用程序 配方中创建的应用程序。

如何做……

执行以下步骤以手动向可扩展应用程序添加新齿轮：

打开命令行终端，导航到在 创建可扩展应用程序 配方中创建的应用程序目录。
在你的应用程序目录中的 .openshift/marker 目录下创建一个名为 disable_auto_scaling 的新标记文件。在 Mac 和 Linux 机器上，你可以使用以下命令：
```
$ touch .openshift/markers/disable_auto_scaling
```
在 Windows 机器上，你可以通过文件菜单创建新文件。
将文件提交到本地 Git 仓库，并使用以下命令将更改推送到 OpenShift 应用程序齿轮 Git 仓库：
```
$ git add .
$ git commit -am "disabled auto scaling"
$ git push
```
重启 HAProxy 卡带，使其不再运行 haproxy_ctld 进程。haproxy_ctld 进程负责发布扩展和缩减事件。请查看以下命令：
```
$ rhc cartridge-restart haproxy
```
现在，要向你的应用程序添加一个新的齿轮，可以使用以下命令：
```
$ rhc scale-up-app --app jobstore
```
要从应用程序中移除一个齿轮，可以使用以下命令：
```
$ rhc scale-down-app --app jobstore
```

工作原理……

OpenShift 可扩展应用程序默认具有自动扩展功能，这意味着它们可以根据并发用户的数量添加或移除 web 卡带齿轮。虽然在大多数情况下自动扩展非常有用，但有时你可能更愿意自己控制扩展行为。你会在可以提前预见到应用程序的 web 流量时启用手动扩展。例如，在节假日或促销活动期间，你提前知道会有更多的访问者访问你的应用程序。在这种情况下，你可以启用手动扩展，确保有足够的齿轮来处理 web 流量。

OpenShift 允许用户使用 rhc scale-up-app 或 rhc scale-down-app 命令手动添加或移除齿轮。这些命令一次添加或移除一个齿轮。在后台，这些命令使用 OpenShift REST API 将扩展和缩减事件发布到代理。OpenShift 代理消费这些请求并据此采取行动。在第 5 步运行 rhc scale-up-app 命令后，你应该能看到 jobstore 应用程序正在使用三个齿轮。你还可以在 HAProxy 状态页面上看到新的齿轮：

$ rhc show-app --app jobstore
jobstore @ http://jobstore-osbook.rhcloud.com/ (uuid: 53d405dd4382ec661c001842)
-------------------------------------------------------------------------------
 Domain:          osbook
 Created:         1:17 AM
 Gears:           3 (defaults to small)

还有更多……

如前所述，rhc scale-up-app 或 scale-down-app 命令使用 REST API 添加或移除 gear。因此，如果你不想使用 OpenShift 工具来执行手动扩展操作，可以直接调用 REST API 来添加或移除应用程序中的 gear。

要使用 curl 扩展应用程序，你可以运行以下命令：

curl -k -X POST https://openshift.redhat.com/broker/rest/domains/{domain_name}/applications/{app_name}/events --user "openshift_login:openshift_login_password" --data "event=scale-up"

将 domain_name、app_name、openshift_login 和 openshift_login_password 替换为相应的值。

要使用 curl 缩减应用程序，你可以运行以下命令：

curl -k -X POST https://openshift.redhat.com/broker/rest/domains/{domain_name}/applications/{app_name}/events --user "openshift_login:openshift_login_password" --data "event=scale-down"

另见

创建可扩展应用程序 配方
启用手动缩放与标记文件 配方

附录 A. 在虚拟机上运行 OpenShift

OpenShift Origin 是 OpenShift PaaS 的免费开源版本。它是 OpenShift Online 和 Enterprise 的上游项目。你将学习如何在你机器上运行虚拟机中运行 OpenShift Origin (VM) 。这将帮助你即使在没有连接互联网时也能使用 OpenShift。你可以使用 OpenShift Origin 虚拟机作为开发环境来测试你的更改，然后，当你准备好进行部署时，可以将源代码推送到 OpenShift Online。要将 OpenShift Origin 虚拟机作为开发环境使用，请运行 rhc setup --server 命令。--server 选项应指向 OpenShift Origin 虚拟机代理。更多详情可以参考第一章中的 指定不同的 OpenShift 服务器主机名 配方，OpenShift 入门。

要准备好环境，你需要在机器上安装 VirtualBox。如果尚未安装，请从官方网站 www.virtualbox.org/ 下载。还需要为你的操作系统安装 7-Zip 软件，你可以从其官方网站 www.7-zip.org/download.html 下载。

执行以下步骤以在虚拟机上运行 OpenShift：

下载 OpenShift Origin 版本 3 虚拟机镜像。虚拟机文件超过 2 GB。你可以运行以下命令：

$ wget https://mirror.openshift.com/pub/origin-server/release/3/images/openshift-origin.zip –secure-protocol=SSLv3

Windows 用户可以通过浏览器下载，或者他们可以先在 Windows 上下载 wget 软件，下载地址是 gnuwin32.sourceforge.net/packages/wget.htm，然后使用该工具下载 OpenShift Origin 虚拟机。
使用 wget 的优势在于你可以通过 -c 选项恢复部分下载。如果你处于网络连接不稳定的地方，这将非常有用，你可以通过以下命令恢复下载：
```
$ wget -c  https://mirror.openshift.com/pub/origin-server/release/3/images/openshift-origin.zip --secure-protocol=SSLv3
```
接下来，使用 7-Zip 文件压缩工具解压缩 zip 压缩包：
```
$ 7z x openshift-origin.zip
```
输入此命令将生成三个额外的文件，如下一个命令所示：
```
$ ls -1t
```
这些文件分别是 OpenShift Origin Release 3.vmx、OpenShift Origin Release 3.vbox 和 origin-rel3.vmdk。
启动 VirtualBox 管理器，并点击新建按钮。请查看以下截图：
修改 OpenShift Origin 虚拟机所需的详细信息。你可以使用任何你喜欢的名称，但必须将类型设置为Linux，版本设置为Fedora（64 位）。请查看以下截图：
接下来，将内存大小设置为 1 GB，因为这样可以为虚拟机提供足够的内存，以便它能良好运行。请查看以下截图：
接下来，你将为新机器添加一个虚拟硬盘。请选择使用现有虚拟硬盘文件选项，然后点击选择虚拟硬盘文件上传按钮。请查看以下截图：
VirtualBox 将显示一个文件选择对话框。浏览并找到origin-rel3.vmdk文件，选择它。点击标有打开的按钮。请查看以下截图：
选择文件后，点击创建来创建一个新的虚拟机。你将在虚拟管理器显示中看到新的虚拟机。请查看以下截图：
接下来，你将设置一个桥接网络适配器，这将允许你从本地机器与 OpenShift Origin 虚拟机进行交互。选择虚拟机，右键点击它，然后点击设置图标：
导航到网络设置，选择适配器 2。勾选启用网络适配器复选框，然后将连接到下拉菜单设置为桥接适配器。最后，设置你想桥接的网络适配器的名称。请查看以下截图：

每个系统的物理网络适配器名称可能不同。完成上述更改后，点击确定。
通过点击启动按钮来启动虚拟机。请查看以下截图：
当虚拟机启动完成后，它将向你展示一个教程，帮助你了解如何使用 OpenShift Origin 虚拟机，如下图所示：

输入yes后，教程将从管理员的角度带你了解 OpenShift Origin 虚拟机的功能。
完成管理员教程后，系统会显示一个菜单，你可以选择与 OpenShift Origin 虚拟机交互的选项。选择第二个选项以连接到 Web 控制台。你将看到 Web 控制台的详细信息，如下图所示：
复制 URL 并粘贴到浏览器中。默认的用户名/密码组合是demo/changeme。请查看以下截图：

使用默认的用户名和密码登录到 Web 控制台。您将被引导到应用创建页面。您可以按照第一章中的使用 Web 控制台创建 WordPress 应用的步骤来创建 WordPress 应用，开始使用 OpenShift。

posted @ 2025-07-08 12:23 绝不原创的飞龙阅读(15) 评论(0) 收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

Openshift-秘籍-全-

Openshift 秘籍（全）

前言

本书内容概述

本书所需的内容

本书适合谁阅读

约定

注意

提示

读者反馈

客户支持

下载示例代码

勘误

盗版

问题

第一章。开始使用 OpenShift

OpenShift 简要介绍

注意

创建 OpenShift Online 账户

准备工作

如何操作…

注意

如何工作…

另见

使用 Web 控制台创建 OpenShift 域

准备工作

如何操作…

它是如何工作的……

还有更多内容…

另见

使用网页控制台创建 WordPress 应用

准备工作

如何操作…

它是如何工作的…

还有更多…

另见

使用 Web 控制台上传 SSH 密钥

准备工作

注意

如何操作…

它是如何工作的…

注意

还有更多…

提示

另见

使用 SSH 密钥密码短语

准备工作

如何操作…

工作原理…

另见

将应用程序克隆到本地机器

准备工作

如何操作…

它是如何工作的…

还有更多…

另见

部署你的第一次更改

准备工作

如何操作…

它是如何工作的…

还有更多…

另见

检查应用程序的配额和限制

准备工作

如何操作…

工作原理…

还有更多内容……

安装 OpenShift rhc 命令行客户端

准备工作

如何操作……

工作原理……

还有更多内容……

参见

使用 rhc 设置 OpenShift 账户

准备工作

如何操作…

它是如何工作的…

还有更多……