Cherrypy-quick-guide

提供：Dev Guides
移動先:案内、検索

CherryPy-はじめに

CherryPyはPythonのWebフレームワークであり、Python開発者向けのHTTPプロトコルへの使いやすいインターフェイスを提供します。 Webアプリケーションライブラリとも呼ばれます。

CherryPyは、Pythonの強みを動的言語として使用して、HTTPプロトコルをモデリングし、APIにバインドします。 Python用の最も古いWebフレームワークの1つであり、クリーンなインターフェイスと信頼性の高いプラットフォームを提供します。

CherryPyの歴史

Remi Delonは、2002年6月下旬にCherryPyの最初のバージョンをリリースしました。 これは、成功したPython Webライブラリの出発点でした。 Remiはフランスのハッカーであり、PythonをWebアプリケーション開発の最大の選択肢の1つとして信頼しています。

Remiが開発したプロジェクトには、このアプローチに興味を持った多くの開発者が集まりました。 アプローチには、次の機能が含まれていました-

  • CherryPyはmodel-view-controllerパターンに近かった。
  • CherryPyクラスは、CherryPyエンジンによって処理およびコンパイルされ、完全なアプリケーションと独自の組み込みWebサーバーが組み込まれた自己完結型のPythonモジュールを生成する必要があります。
  • CherryPyは、URLとそのクエリ文字列をPythonのメソッド呼び出しにマッピングできます。たとえば-
http://somehost.net/echo?message=hello would map to echo(message='hello')

CherryPyプロジェクトでの2年間の開発の間に、コミュニティによってサポートされ、レミはいくつかの改善されたバージョンをリリースしました。

2004年6月、プロジェクトの将来と、同じアーキテクチャでプロジェクトを継続するかどうかについての議論が始まりました。 その後、いくつかのプロジェクトの常連によるブレーンストーミングと議論がオブジェクト発行エンジンとフィルターの概念につながり、間もなくCherryPy2の中核部分になりました。2004年10月に、CherryPy 2 alphaの最初のバージョンがこれらの中核的なアイデア。 CherryPy 2.0は大成功でした。ただし、その設計は依然として改善可能であり、リファクタリングが必要であると認識されていました。

フィードバックに基づいて議論した後、CherryPyのAPIはさらに洗練され、2005年10月にCherryPy 2.1.0がリリースされました。 さまざまな変更の後、チームは2006年4月にCherryPy 2.2.0をリリースしました。

CherryPyの強み

CherryPyの次の機能は、その長所とみなされます-

単純さ

CherryPyでのプロジェクトの開発は、Pythonの規則とインデントに従って開発された数行のコードを持つ単純なタスクです。

CherryPyも非常にモジュール化されています。 主要なコンポーネントは適切なロジックコンセプトで適切に管理され、親クラスは子クラスに拡張可能です。

力

CherryPyはPythonのすべての力を活用しています。 また、世界クラスのアプリケーションの開発に必要な強力な拡張ポイントであるツールとプラグインも提供します。

オープンソース

CherryPyは、オープンソースのPython Webフレームワーク（オープンソースのBSDライセンスの下でライセンスされています）です。つまり、このフレームワークはZEROコストで商業的に使用できます。

コミュニティヘルプ

さまざまな種類の質問と回答で完全なサポートを提供する献身的なコミュニティがあります。 コミュニティは、初心者レベルから上級レベルまで、開発者に完全な支援を提供しようとします。

展開

アプリケーションを展開するには、費用対効果の高い方法があります。 CherryPyには、アプリケーションをホストするための独自の本番対応HTTPサーバーが含まれています。 CherryPyは、WSGI準拠のゲートウェイにもデプロイできます。

CherryPy-環境設定

CherryPyは、ほとんどのオープンソースプロジェクトのようなパッケージで提供されており、次のようなさまざまな方法でダウンロードおよびインストールできます-

  • Tarballを使用する
  • easy_installを使用する
  • Subversionを使用する

必要条件

CherryPyフレームワークのインストールの基本的な要件は次のとおりです-

  • バージョン2.4以降のPython
  • CherryPy 3.0

Pythonモジュールのインストールは簡単なプロセスと見なされます。 インストールには、次のコマンドの使用が含まれます。 

python setup.py build
python setup.py install

Pythonのパッケージは、次のデフォルトのディレクトリに格納されています-

  • UNIXまたはLinuxでは、
/usr/local/lib/python2.4/site-packages
or
/usr/lib/python2.4/site-packages
  • Microsoft Windowsでは、
C:\Python or C:\Python2x
  • Mac OSでは、
Python:Lib:site-package

Tarballを使用したインストール

Tarballは、ファイルまたはディレクトリの圧縮アーカイブです。 CherryPyフレームワークは、各リリース（アルファ版、ベータ版、安定版）にTarballを提供します。

ライブラリの完全なソースコードが含まれています。 この名前は、UNIXおよびその他のオペレーティングシステムで使用されるユーティリティに由来しています。

以下は、tarボールを使用してCherryPyをインストールするために従うべき手順です-

ステップ2-Tarballがダウンロードされたディレクトリを検索し、解凍します。 Linuxオペレーティングシステムの場合、次のコマンドを入力します- 

tar zxvf cherrypy-x.y.z.tgz

Microsoft Windowsの場合、ユーザーは7-ZipやWinzipなどのユーティリティを使用して、グラフィカルインターフェイスを介してアーカイブを解凍できます。

  • ステップ3 *-新しく作成したディレクトリに移動し、次のコマンドを使用してCherryPyをビルドします-
python setup.py build

グローバルインストールの場合、次のコマンドを使用する必要があります- 

python setup.py install

easy_installを使用したインストール

Python Enterprise Application Kit（PEAK）は、Easy Installという名前のpythonモジュールを提供します。 これにより、Pythonパッケージの展開が容易になります。 このモジュールは、Pythonアプリケーションと製品のダウンロード、ビルド、デプロイの手順を簡素化します。

CherryPyをインストールする前に、システムにEasy Installをインストールする必要があります。

  • ステップ2 *-次のコマンドを使用して、簡易インストールをインストールします。
easy_install product_name
  • ステップ3 *-easy_installはPythonパッケージインデックス（PyPI）を検索して、指定された製品を見つけます。 PyPIは、すべてのPython製品の情報の集中リポジトリです。

次のコマンドを使用して、CherryPyの最新バージョンを展開します- 

easy_install cherrypy
  • ステップ4 *-easy_installはCherryPyをダウンロードし、ビルドし、Python環境にグローバルにインストールします。

Subversionを使用したインストール

Subversionを使用したCherryPyのインストールは、次の状況で推奨されます-

  • 機能が存在するか、バグが修正されており、開発中のコードでのみ利用可能です。
  • 開発者がCherryPy自体で作業する場合。
  • ユーザーがバージョン管理リポジトリのメインブランチからのブランチを必要とする場合。
  • 前のリリースのバグ修正用。

サブバージョン化の基本原則は、リポジトリを登録し、各バージョンを追跡することです。各バージョンには、一連の変更が含まれます。

Subversionを使用してCherryPyのインストールを理解するには、次の手順に従います。

  • ステップ1 *-プロジェクトの最新バージョンを使用するには、Subversionリポジトリにあるトランクフォルダーをチェックアウトする必要があります。
  • ステップ2 *-シェルから次のコマンドを入力します
svn co http://svn.cherrypy.org/trunk cherrypy
  • ステップ3 *-次に、CherryPyディレクトリを作成し、そこに完全なソースコードをダウンロードします。

インストールのテスト

Javaなどのアプリケーションの場合と同じ方法で、アプリケーションがシステムに適切にインストールされているかどうかを確認する必要があります。

前の章で言及した3つの方法のいずれかを選択して、CherryPyを環境にインストールおよびデプロイできます。 CherryPyは次のようにPythonシェルからインポートできる必要があります- 

import cherrypy

cherrypy.__version__
'3.0.0'

CherryPyがローカルシステムのPython環境にグローバルにインストールされていない場合、PYTHONPATH環境変数を設定する必要があります。そうでない場合、次のようにエラーが表示されます- 

import cherrypy

Traceback (most recent call last):
File "<stdin>", line 1, in ?
ImportError: No module named cherrypy

CherryPy-語彙

CherryPyの動作を理解するために定義する必要があるいくつかの重要なキーワードがあります。 キーワードと定義は次のとおりです-

S.No Keyword & Definition
1.

Web Server

これは、HTTPプロトコルを処理するインターフェースです。 その目標は、HTTP要求をアプリケーションサーバーに変換して、応答を取得することです。

2.

Application

これは、情報を収集するソフトウェアです。

3.

Application server

1つ以上のアプリケーションを保持するコンポーネントです

4.

Web application server

Webサーバーとアプリケーションサーバーの組み合わせです。

例

次の例は、CherryPyのサンプルコードを示しています- 

import cherrypy

class demoExample:
   def index(self):
   return "Hello World!!!"
   index.exposed = True
cherrypy.quickstart(demoExample())

コードがどのように機能するかを理解しましょう-

  • CherryPy という名前のパッケージは、適切に機能するように、常に指定されたクラスにインポートされます。
  • 上記の例では、 index という名前の関数はパラメーター「Hello World !!!」を返します。
  • 最後の行はWebサーバーを起動し、指定されたクラス（ここではdemoExample）を呼び出し、デフォルトの関数インデックスに記載されている値を返します。

サンプルコードは、次の出力を返します-

デモの例

組み込みのHttpサーバーと内部エンジン

CherryPyには、独自のWeb（HTTP）サーバーが付属しています。 そのため、CherryPyは自己完結型であり、ユーザーはライブラリを取得してから数分以内にCherryPyアプリケーションを実行できます。

  • Webサーバー*は、アプリケーションへのゲートウェイとして機能し、すべての要求と応答が追跡されます。

Webサーバーを起動するには、ユーザーは次の呼び出しを行う必要があります- 

cherryPy.server.quickstart()

CherryPyの*内部エンジン*は、次の活動を担当します-

  • 要求および応答オブジェクトの作成と管理。
  • CherryPyプロセスの制御と管理。

CherryPy –設定

このフレームワークには、HTTPサーバーをパラメーター化できる独自の構成システムが付属しています。 構成の設定は、INI形式に近い構文のテキストファイルまたは完全なPython辞書として保存できます。

CherryPyサーバーインスタンスを構成するには、開発者は設定のグローバルセクションを使用する必要があります。 

global_conf = {
   'global': {
      'server.socket_host': 'localhost',
      'server.socket_port': 8080,
   },
}

application_conf = {
   '/style.css': {
      'tools.staticfile.on': True,
      'tools.staticfile.filename': os.path.join(_curdir, 'style.css'),
   }
}

This could be represented in a file like this:
[global]
server.socket_host = "localhost"
server.socket_port = 8080
[/style.css]
tools.staticfile.on = True
tools.staticfile.filename = "/full/path/to.style.css"

HTTPコンプライアンス

CherryPyはゆっくりと進化していますが、HTTP/1.0のサポートを含むHTTP仕様のコンパイルが含まれ、後でHTTP/1.1のサポートで転送されます。

CherryPyは、仕様のすべての必須レベルではなく、すべての必須レベルと必須レベルを実装しているため、HTTP/1.1に条件付きで準拠していると言われています。 したがって、CherryPyはHTTP/1.1の次の機能をサポートしています-

  • クライアントがHTTP/1.1をサポートすると主張する場合、指定されたプロトコルバージョンで行われた要求でヘッダーフィールドを送信する必要があります。 完了していない場合、CherryPyはすぐにリクエストの処理を停止します。
  • CherryPyは、すべての構成で使用されるDateヘッダーフィールドを生成します。
  • CherryPyは、クライアントのサポートで応答ステータスコード（100）を処理できます。
  • CherryPyのビルトインHTTPサーバーは、Connection：Keep-Aliveヘッダーを使用することにより、HTTP/1.1のデフォルトである持続的接続をサポートします。
  • CherryPyは、正しくチャンクされたリクエストとレスポンスを処理します。
  • CherryPyは、If-Modified-SinceおよびIf-Unmodified-Sinceヘッダーという2つの異なる方法でリクエストをサポートし、リクエストに応じて応答を送信します。
  • CherryPyでは、任意のHTTPメソッドを使用できます。
  • CherryPyは、クライアントとサーバーに設定された設定との間のHTTPバージョンの組み合わせを処理します。

マルチスレッドアプリケーションサーバー

CherryPyは、マルチスレッドの概念に基づいて設計されています。 開発者がCherryPy名前空間に値を取得または設定するたびに、マルチスレッド環境で実行されます。

cherrypy.requestとcherrypy.responseはどちらもスレッドデータコンテナです。これは、実行時にどのリクエストがプロキシされるかを知ることで、アプリケーションが独立してそれらを呼び出すことを意味します。

スレッドパターンを使用するアプリケーションサーバーは、スレッドの使用が同期要件による問題の可能性を高めると見なされるため、高く評価されていません。

他の選択肢は次のとおりです-

マルチプロセスパターン

各リクエストは、独自のPythonプロセスによって処理されます。 ここでは、サーバーのパフォーマンスと安定性が優れていると見なすことができます。

非同期パターン

ここでは、新しい接続を受け入れてデータをクライアントに送り返すことは、要求プロセスから非同期に行われます。 この手法は、その効率性で知られています。

URLディスパッチ

CherryPyコミュニティは、より柔軟になりたいと考えており、ディスパッチャ向けの他のソリューションが評価されます。 CherryPy 3は、他​​のビルトインディスパッチャーを提供し、独自のディスパッチャーを作成して使用する簡単な方法を提供します。

  • HTTPメソッドの開発に使用されるアプリケーション。 （GET、POST、PUTなど）
  • URLでルートを定義するもの– Routes Dispatcher

HTTPメソッドディスパッチャー

一部のアプリケーションでは、URIはアクションに依存せず、アクションはリソース上でサーバーによって実行されます。

たとえば、* http：//xyz.com/album/delete/10*

URIには、クライアントが実行したい操作が含まれています。

デフォルトでは、CherryPyディスパッチャーは次のようにマッピングされます- 

album.delete(12)

上記のディスパッチャは正しく言及されていますが、次の方法で独立させることができます- 

http://xyz.com/album/10

ユーザーは、サーバーが正確なページをどのようにディスパッチするか疑問に思うかもしれません。 この情報は、HTTP要求自体によって伝送されます。 クライアントからサーバーへのリクエストがある場合、CherryPyは最適なハンドラーを探します。ハンドラーはURIがターゲットとするリソースの表現です。 

DELETE/album/12 HTTP/1.1

ルートディスパッチャー

これは、ディスパッチに必要なメソッドのパラメータのリストです-

  • nameパラメーターは、接続するルートの一意の名前です。
  • ルートは、URIに一致するパターンです。
  • コントローラーは、ページハンドラーを含むインスタンスです。
  • Routesディスパッチャーを使用すると、URIに一致するパターンが接続され、特定のページハンドラーが関連付けられます。

例

それがどのように機能するかを理解するために例を挙げましょう- 

import random
import string
import cherrypy

class StringMaker(object):
   @cherrypy.expose
   def index(self):
      return "Hello! How are you?"

   @cherrypy.expose
   def generate(self, length=9):
      return ''.join(random.sample(string.hexdigits, int(length)))

if __name__ == '__main__':
   cherrypy.quickstart(StringMaker ())

上記のコードの出力を取得するには、以下の手順に従ってください-

ステップ1 *-上記のファイルを *tutRoutes.py として保存します。

  • ステップ2 *-次のURLにアクセスします-
http://localhost:8080/generate?length=10
  • ステップ3 *-次の出力を受け取ります-

ルートディスパッチャー

CherryPy-ツールボックス

CherryPy内では、組み込みツールはCherryPyライブラリを呼び出すための単一のインターフェースを提供します。 CherryPyで定義されたツールは、次の方法で実装することができます-

  • 構成設定から
  • Pythonデコレータとして、またはページハンドラの特別な_cp_config属性を介して
  • 任意の関数内から適用できるPython呼び出し可能オブジェクトとして

基本認証ツール

このツールの目的は、アプリケーションで設計されたアプリケーションに基本認証を提供することです。

引数

このツールは、次の引数を使用します-

Name Default Description
realm N/A String defining the realm value.
users N/A Dictionary of the form − username:password or a Python callable function returning such a dictionary.
encrypt None Python callable used to encrypt the password returned by the client and compare it with the encrypted password provided in the users dictionary.

例

それがどのように機能するかを理解するために例を挙げましょう- 

import sha
import cherrypy

class Root:
@cherrypy.expose
def index(self):

return """
<html>
   <head></head>
   <body>
      <a href = "admin">Admin </a>
   </body>
</html>
"""

class Admin:

@cherrypy.expose
def index(self):
return "This is a private area"

if __name__ == '__main__':
def get_users():
# 'test': 'test'
return {'test': 'b110ba61c4c0873d3101e10871082fbbfd3'}
def encrypt_pwd(token):

return sha.new(token).hexdigest()
   conf = {'/admin': {'tools.basic_auth.on': True,
      tools.basic_auth.realm': 'Website name',
      'tools.basic_auth.users': get_users,
      'tools.basic_auth.encrypt': encrypt_pwd}}
   root = Root()
root.admin = Admin()
cherrypy.quickstart(root, '/', config=conf)
*get_users* 関数は、ハードコーディングされた辞書を返しますが、データベースまたはその他の場所から値をフェッチします。 クラス管理者には、CherryPyの認証組み込みツールを使用するこの関数が含まれています。 認証により、パスワードとユーザーIDが暗号化されます。

基本的な認証ツールは、パスワードが侵入者によってエンコードおよびデコードされる可能性があるため、実際には安全ではありません。

キャッシングツール

このツールの目的は、CherryPyで生成されたコンテンツのメモリキャッシュを提供することです。

引数

このツールは、次の引数を使用します-

Name Default Description
invalid_methods ("POST", "PUT", "DELETE") Tuples of strings of HTTP methods not to be cached. These methods will also invalidate (delete) any cached copy of the resource.
cache_Class MemoryCache Class object to be used for caching

デコードツール

このツールの目的は、着信要求パラメーターをデコードすることです。

引数

このツールは、次の引数を使用します-

Name Default Description
encoding None It looks for the content-type header
Default_encoding "UTF-8" Default encoding to be used when none is provided or found.

例

それがどのように機能するかを理解するために例を挙げましょう- 

import cherrypy
from cherrypy import tools

class Root:
@cherrypy.expose
def index(self):

return """
<html>
   <head></head>
   <body>
      <form action = "hellol" method = "post">
         <input type = "text" name = "name" value = ""/>
         <input type = ”submit” name = "submit"/>
      </form>
   </body>
</html>
"""

@cherrypy.expose
@tools.decode(encoding='ISO-88510-1')
def hello(self, name):
return "Hello %s" % (name, )
if __name__ == '__main__':
cherrypy.quickstart(Root(), '/')

上記のコードは、ユーザーから文字列を取得し、ユーザーを "hellol"ページにリダイレクトします。このページでは、指定された名前の "Hello"として表示されます。

上記のコードの出力は次のとおりです-

デコードツール 

hellol

デコードツールの出力

CherryPy-実用的なアプリケーション

フルスタックアプリケーションは、ファイルのコマンドまたは実行を介して新しいアプリケーションを作成する機能を提供します。

web2pyフレームワークのようなPythonアプリケーションを検討してください。プロジェクト/アプリケーション全体がMVCフレームワークの観点から作成されます。 同様に、CherryPyを使用すると、ユーザーは要件に従ってコードのレイアウトを設定および構成できます。

この章では、CherryPyアプリケーションを作成して実行する方法を詳細に学習します。

ファイルシステム

アプリケーションのファイルシステムは、次のスクリーンショットに示されています-

ファイルシステム

ここに私たちがファイルシステムに持っているさまざまなファイルの簡単な説明があります-

  • config.py -すべてのアプリケーションには設定ファイルとそれをロードする方法が必要です。 この機能はconfig.pyで定義できます。
  • controllers.py -MVCはユーザーに人気のあるデザインパターンです。 controllers.pyは、_cherrypy.tree_にマウントされるすべてのオブジェクトが実装される場所です。
  • models.py -このファイルは、一部のサービスまたは永続データの保存のためにデータベースと直接やり取りします。
  • server.py -このファイルは、ロードバランシングプロキシで適切に動作する本番対応Webサーバーと対話します。
  • 静的-すべてのCSSおよび画像ファイルが含まれます。
  • Views -特定のアプリケーションのすべてのテンプレートファイルが含まれます。

例

CherryPyアプリケーションを作成する手順を詳しく学びましょう。

  • ステップ1 *-アプリケーションを含むアプリケーションを作成します。
  • ステップ2 *-ディレクトリ内で、プロジェクトに対応するpythonパッケージを作成します。 geditディレクトリを作成し、init.pyファイルを同じディレクトリに含めます。
  • ステップ3 *-パッケージ内に、次の内容のcontrollers.pyファイルを含めます-
#!/usr/bin/env python

import cherrypy

class Root(object):

   def __init__(self, data):
      self.data = data

   @cherrypy.expose
   def index(self):
      return 'Hi! Welcome to your application'

def main(filename):
   data = {} # will be replaced with proper functionality later

   # configuration file
   cherrypy.config.update({
      'tools.encode.on': True, 'tools.encode.encoding': 'utf-8',
      'tools.decode.on': True,
      'tools.trailing_slash.on': True,
      'tools.staticdir.root': os.path.abspath(os.path.dirname(__file__)),
   })

   cherrypy.quickstart(Root(data), '/', {
      '/media': {
         'tools.staticdir.on': True,
         'tools.staticdir.dir': 'static'
      }
   })

if __name__ == '__main__':
main(sys.argv[1])
  • ステップ4 *-ユーザーがフォームを介して値を入力するアプリケーションを考えます。 アプリケーションにindexlとsubmitlの2つのフォームを含めましょう。

ステップ5 *-上記のコントローラーのコードには、 index（）*があります。これはデフォルトの関数であり、特定のコントローラーが呼び出されると最初にロードされます。

ステップ6 *- index（）*メソッドの実装は、次の方法で変更できます- 

@cherrypy.expose
   def index(self):
      tmpl = loader.load('indexl')

      return tmpl.generate(title='Sample').render('html', doctype='html')
  • ステップ7 *-これは、指定されたアプリケーションの起動時にindexlをロードし、指定された出力ストリームに送信します。 indexlファイルは次のとおりです-

インデックス

<!DOCTYPE html >
<html>
   <head>
      <title>Sample</title>
   </head>

   <body class = "index">
      <div id = "header">
         <h1>Sample Application</h1>
      </div>

      <p>Welcome!</p>

      <div id = "footer">
         <hr>
      </div>

   </body>

</html>

ステップ8 *-名前やタイトルなどの値を受け入れるフォームを作成する場合は、 *controller.py のRootクラスにメソッドを追加することが重要です。 

@cherrypy.expose
   def submit(self, cancel = False, **value):

      if cherrypy.request.method == 'POST':
         if cancel:
            raise cherrypy.HTTPRedirect('/') # to cancel the action
         link = Link(**value)
         self.data[link.id] = link
         raise cherrypy.HTTPRedirect('/')
      tmp = loader.load('submitl')
      streamValue = tmp.generate()

      return streamValue.render('html', doctype='html')
*Step 9* -submitlに含まれるコードは次のとおりです-
<!DOCTYPE html>
   <head>
      <title>Input the new link</title>
   </head>

   <body class = "submit">
      <div id = " header">
         <h1>Submit new link</h1>
      </div>

      <form action = "" method = "post">
         <table summary = "">
            <tr>
               <th><label for = " username">Your name:</label></th>
               <td><input type = " text" id = " username" name = " username"/></td>
            </tr>

            <tr>
               <th><label for = " url">Link URL:</label></th>
               <td><input type = " text" id=" url" name= " url"/></td>
            </tr>

            <tr>
               <th><label for = " title">Title:</label></th>
               <td><input type = " text" name = " title"/></td>
            </tr>

            <tr>
               <td></td>
               <td>
                  <input type = " submit" value = " Submit"/>
                  <input type = " submit" name = " cancel" value = "Cancel"/>
               </td>
            </tr>

         </table>

      </form>
      <div id = "footer">
      </div>

   </body>

</html>
  • ステップ10 *-次の出力が表示されます-

ファイルシステム出力

ここでは、メソッド名は「POST」として定義されています。 ファイルで指定されたメソッドを相互検証することは常に重要です。 メソッドに「POST」メソッドが含まれる場合、データベースの適切なフィールドで値を再確認する必要があります。

メソッドに「GET」メソッドが含まれている場合、保存される値はURLに表示されます。

CherryPy-Webサービス

Webサービスは、アプリケーションまたはシステム間のデータ交換を支援するWebベースのコンポーネントのセットであり、オープンプロトコルおよび標準も含まれます。 Webで公開、使用、および検索できます。

Webサービスには、RWS（RESTfUL Webサービス）、WSDL、SOAPなどのさまざまなタイプがあります。

REST —代表的な状態の転送

リモートアクセスプロトコルの一種。リモートプロシージャを呼び出す代わりに状態を操作するために使用できるクライアントからサーバーに状態を転送します。

  • 特定のエンコーディングまたは構造、および有用なエラーメッセージを返す方法を定義しません。
  • HTTP「動詞」を使用して、状態転送操作を実行します。
  • リソースは、URLを使用して一意に識別されます。
  • これはAPIではなく、APIトランスポートレイヤーです。

RESTは、ネットワーク上のリソースの命名法を維持し、これらのリソースで操作を実行する統合メカニズムを提供します。 各リソースは、少なくとも1つの識別子で識別されます。 RESTインフラストラクチャがHTTPベースで実装されている場合、これらの識別子は* Uniform Resource Identifiers（URI）*と呼ばれます。

以下は、URIセットの2つの一般的なサブセットです-

Subset Full form Example
URL Uniform Resource Locator http://www.gmail.com/
URN Uniform Resource Name urn:isbn:0-201-71088-9 urn:uuid:13e8cf26-2a25-11db-8693-000ae4ea7d46

CherryPyアーキテクチャの実装を理解する前に、CherryPyのアーキテクチャに注目しましょう。

CherryPyには、次の3つのコンポーネントが含まれています-

  • cherrypy.engine -プロセスの起動/分解およびイベント処理を制御します。
  • cherrypy.server -WSGIまたはHTTPサーバーを構成および制御します。
  • cherrypy.tools -HTTPリクエストの処理に直交するユーティリティのツールボックス。

CherryPyを介したRESTインターフェイス

RESTful Webサービスは、以下の助けを借りてCherryPyアーキテクチャの各セクションを実装します-

  • 認証
  • 承認
  • 構造
  • カプセル化
  • エラー処理

認証

認証は、対話しているユーザーの検証に役立ちます。 CherryPyには、各認証方法を処理するツールが含まれています。 

def authenticate():
   if not hasattr(cherrypy.request, 'user') or cherrypy.request.user is None:
      # < Do stuff to look up your users >

      cherrypy.request.authorized = False # This only authenticates.
         Authz must be handled separately.

      cherrypy.request.unauthorized_reasons = []
      cherrypy.request.authorization_queries = []

cherrypy.tools.authenticate = \
   cherrypy.Tool('before_handler', authenticate, priority=10)

上記の関数authenticate（）は、クライアントまたはユーザーの存在を検証するのに役立ちます。 組み込みのツールは、体系的な方法でプロセスを完了するのに役立ちます。

承認

承認は、URIを介してプロセスの健全性を維持するのに役立ちます。 このプロセスは、ユーザートークンリードによるオブジェクトのモーフィングにも役立ちます。 

def authorize_all():
   cherrypy.request.authorized = 'authorize_all'

cherrypy.tools.authorize_all = cherrypy.Tool('before_handler', authorize_all, priority=11)

def is_authorized():
   if not cherrypy.request.authorized:
      raise cherrypy.HTTPError("403 Forbidden",
         ','.join(cherrypy.request.unauthorized_reasons))

cherrypy.tools.is_authorized = cherrypy.Tool('before_handler', is_authorized,
priority = 49)

cherrypy.config.update({
   'tools.is_authorized.on': True,
   'tools.authorize_all.on': True
})

承認の組み込みツールは、前の例で述べたように、体系的な方法でルーチンを処理するのに役立ちます。

構造

APIの構造を維持すると、アプリケーションのURIをマッピングする作業負荷を軽減できます。 APIを見つけやすくクリーンな状態に保つことが常に必要です。 CherryPyフレームワークのAPIの基本構造には次のものが必要です-

  • アカウントとユーザー
  • 自動応答
  • 接触
  • File
  • フォルダ
  • リストとフィールド *メッセージとバッチ

カプセル化

カプセル化は、軽量で人間が読める、さまざまなクライアントがアクセスできるAPIの作成に役立ちます。 作成、取得、更新、削除に伴うアイテムのリストには、APIのカプセル化が必要です。

エラー処理

このプロセスは、APIが特定の本能で実行に失敗した場合、エラーを管理します。 たとえば、400は不正なリクエスト用で、403は不正なリクエスト用です。

例

データベース、検証、またはアプリケーションエラーの例として、以下を考慮してください。 

import cherrypy
import json

def error_page_default(status, message, traceback, version):
   ret = {
      'status': status,
      'version': version,
      'message': [message],
      'traceback': traceback
   }

   return json.dumps(ret)

class Root:
   _cp_config = {'error_page.default': error_page_default}

@cherrypy.expose
   def index(self):
      raise cherrypy.HTTPError(500, "Internal Sever Error")
cherrypy.quickstart(Root())

上記のコードは、次の出力を生成します-

エラー処理

API（アプリケーションプログラミングインターフェース）の管理は、組み込みのアクセスツールにより、CherryPyを介して簡単に行えます。

HTTPメソッド

リソースで動作するHTTPメソッドのリストは次のとおりです-

S.No HTTP Method & Operation
1.
  • HEAD*

リソースメタデータを取得します。

2.

GET

リソースのメタデータとコンテンツを取得します。

3.

POST

リクエスト本文に含まれるデータを使用して、新しいリソースを作成するようサーバーに要求します。

4.

PUT

既存のリソースを要求本文に含まれているリソースで置き換えるようにサーバーに要求します。

5.

DELETE

そのURIで識別されるリソースを削除するようサーバーに要求します。

6.

OPTIONS

グローバルに、または特定のリソースに対して機能に関する詳細を返すようにサーバーに要求します。

Atom Publishing Protocol（APP）

APPは、Webリソースの公開と編集を可能にするHTTPのアプリケーションレベルのプロトコルとしてAtomコミュニティから生まれました。 APPサーバーとクライアント間のメッセージの単位は、Atom XMLドキュメント形式に基づいています。

Atom Publishing Protocolは、HTTPとそのメカニズム、およびAtom XMLドキュメント形式をメッセージの単位として使用して、APPサービスとユーザーエージェント間の一連の操作を定義します。

APPは最初にサービスドキュメントを定義します。これは、APPサービスが提供するさまざまなコレクションのURIをユーザーエージェントに提供します。

例

APPがどのように機能するかを示すために例を挙げましょう- 

<?xml version = "1.0" encoding = "UTF-8"?>
<service xmlns = "http://purl.org/atom/app#" xmlns:atom = "http://www.w3.org/2005/Atom">

   <workspace>
      <collection href = "http://host/service/atompub/album/">
         <atom:title> Albums</atom:title>
         <categories fixed = "yes">
            <atom:category term = "friends"/>
         </categories>
      </collection>

      <collection href = "http://host/service/atompub/film/">
         <atom:title>Films</atom:title>
         <accept>image/png,image/jpeg</accept>
      </collection>
   </workspace>

</service>

APPは、次の表に記載されているHTTPメソッドを使用して、コレクションのメンバーまたはコレクション自体に対して基本的なCRUD操作を実行する方法を指定します-

Operation HTTP Method Status Code Content
Retrieve GET 200 An Atom entry representing the resource
Create POST 201 The URI of the newly created resource via the Location and Content-Location headers
Update PUT 200 An Atom entry representing the resource
Delete DELETE 200 None

CherryPy-プレゼンテーション層

プレゼンテーション層は、通過する通信が目的の受信者を確実に対象とするようにします。 CherryPyは、さまざまなテンプレートエンジンによるプレゼンテーション層の機能を維持しています。

テンプレートエンジンは、ビジネスロジックの助けを借りてページの入力を取得し、目的の対象者のみを対象とする最終ページに処理します。

キッド—テンプレートエンジン

*Kid* は、処理されるテンプレートの名前（必須）と、テンプレートのレンダリング時に渡されるデータの入力を含む単純なテンプレートエンジンです。

テンプレートを初めて作成すると、Kidはテンプレートのキャッシュバージョンとして提供できるPythonモジュールを作成します。 

*kid.Template* 関数は、出力コンテンツのレンダリングに使用できるテンプレートクラスのインスタンスを返します。

テンプレートクラスは、コマンドの次のセットを提供します-

S.No Command & Description
1.

serialize

出力コンテンツを文字列として返します。

2.

generate

出力コンテンツをイテレーターとして返します。

3.

write

出力コンテンツをファイルオブジェクトにダンプします。

これらのコマンドで使用されるパラメータは次のとおりです-

S.No Command & Description
1.

encoding

出力コンテンツをエンコードする方法を通知します

2.

fragment

これは、XMLプロローグまたはDoctypeに伝えるブール値です

3.

output

このタイプのシリアル化は、コンテンツのレンダリングに使用されます

例

*kid* の仕組みを理解するために例を挙げましょう-
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html xmlns:py = "http://purl.org/kid/ns#">
   <head>
      <title>${title}</title>
      <link rel = "stylesheet" href = "style.css"/>
   </head>

   <body>
      <p>${message}</p>
   </body>
</html>

The next step after saving the file is to process the template via the Kid engine.

import kid

params = {'title': 'Hello world!!', 'message': 'CherryPy.'}
t = kid.Template('helloworld.kid', **params)
print t.serialize(output='html')

子供の属性

以下はキッドの属性です-

XMLベースのテンプレート言語

XMLベースの言語です。 Kidテンプレートは、適切な命名規則を持つ整形式のXMLドキュメントである必要があります。

KidはXML要素内に属性を実装して、要素に到達するために従うアクションの基礎となるエンジンを更新します。 XMLドキュメント内の他の既存の属性と重複しないように、Kidは独自の名前空間を導入しています。 

<p py:if = "...">...</p>

可変置換

Kidには、変数置換スキームと単純なアプローチ、$ \ {variable-name}が付属しています。

変数は、要素の属性で使用することも、要素のテキストコンテンツとして使用することもできます。 キッドは、実行が行われるたびに変数を評価します。

ユーザーがリテラル文字列の出力を$ \ {something}として必要とする場合、変数置換を使用して、ドル記号を2つ重ねることでエスケープできます。

条件文

テンプレート内のさまざまなケースを切り替えるには、次の構文が使用されます- 

<tag py:if = "expression">...</tag>

ここで、タグは要素の名前、たとえばDIVまたはSPANです。

式はPython式です。 ブール値としてTrueと評価される場合、要素は出力コンテンツに含まれます。そうでない場合、出力コンテンツの一部にはなりません。

ループ機構

キッドの要素をループするには、次の構文が使用されます- 

<tag py:for = "expression">...</tag>

ここで、タグは要素の名前です。 式は、[…​]の値などのPython式です。

例

次のコードは、ループメカニズムの仕組みを示しています- 

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
   <head>
      <title>${title}</title>
      <link rel = "stylesheet" href = "style.css"/>
   </head>

   <body>
      <table>
         <caption>A few songs</caption>
         <tr>
            <th>Artist</th>
            <th>Album</th>
            <th>Title</th>
         </tr>

         <tr py:for = "info in infos">
            <td>${info['artist']}</td>
            <td>${info['album']}</td>
            <td>${info['song']}</td>
         </tr>
      </table>
   </body>
</html>

import kid

params = discography.retrieve_songs()
t = kid.Template('songs.kid', **params)
print t.serialize(output='html')

ループ機構を備えた上記のコードの*出力*は次のとおりです-

ループ出力

CherryPy-Ajaxの使用

2005年まで、すべてのWebアプリケーションでのパターンは、ページごとに1つのHTTPリクエストを管理することでした。 あるページから別のページに移動するには、ページ全体をロードする必要がありました。 これにより、パフォーマンスが大幅に低下します。

したがって、AJAX、XML、およびJSONをそれらに埋め込むために使用される*リッチクライアントアプリケーション*が増加しました。

AJAX

非同期JavaScriptおよびXML（AJAX）は、高速で動的なWebページを作成する手法です。 AJAXでは、サーバーと舞台裏で少量のデータを交換することにより、Webページを非同期に更新できます。 つまり、ページ全体をリロードすることなく、Webページの一部を更新することが可能です。

Googleマップ、Gmail、YouTube、FacebookはAJAXアプリケーションの例です。

Ajaxは、JavaScriptを使用してHTTPリクエストを送信するという考えに基づいています。より具体的には、AJAXはこれらの操作を実行するためにXMLHttpRequestオブジェクトとそのAPIに依存しています。

JSON

JSONは、JavaScriptアプリケーションがそれらを評価し、後で操作できるJavaScriptオブジェクトに変換できるように、シリアル化されたJavaScriptオブジェクトを運ぶ方法です。

たとえば、ユーザーがJSON形式でフォーマットされたアルバムオブジェクトをサーバーに要求すると、サーバーは次のように出力を返します- 

{'description': 'This is a simple demo album for you to test', 'author': ‘xyz’}

これで、データはJavaScript連想配列になり、説明フィールドにアクセスできます- 

data ['description'];

AJAXをアプリケーションに適用する

indexlおよびJqueryプラグインを含む「media」という名前のフォルダーと、AJAX実装を含むファイルを含むアプリケーションを考えてみます。 ファイル名を「ajax_app.py」と考えてみましょう

ajax_app.py

import cherrypy
import webbrowser
import os
import simplejson
import sys

MEDIA_DIR = os.path.join(os.path.abspath("."), u"media")

class AjaxApp(object):
   @cherrypy.expose
   def index(self):
      return open(os.path.join(MEDIA_DIR, u'indexl'))

   @cherrypy.expose
   def submit(self, name):
      cherrypy.response.headers['Content-Type'] = 'application/json'
      return simplejson.dumps(dict(title="Hello, %s" % name))

config = {'/media':
   {'tools.staticdir.on': True,
   'tools.staticdir.dir': MEDIA_DIR,}
}

def open_page():
webbrowser.open("http://127.0.0.1:8080/")
cherrypy.engine.subscribe('start', open_page)
cherrypy.tree.mount(AjaxApp(), '/', config=config)
cherrypy.engine.start()

クラス「AjaxApp」は、メディアフォルダーに含まれている「indexl」のWebページにリダイレクトします。 

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
   " http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns = "http://www.w3.org/1999/xhtml" lang = "en" xml:lang = "en">
   <head>
      <title>AJAX with jQuery and cherrypy</title>
      <meta http-equiv = " Content-Type" content = " text/html; charset = utf-8"/>
      <script type = " text/javascript" src = "/media/jquery-1.4.2.min.js"></script>

      <script type = " text/javascript">
         $(function() {

           //When the testform is submitted...
            $("#formtest").submit(function() {

              //post the form values via AJAX...
               $.post('/submit', {name: $("#name").val()}, function(data) {

                 //and set the title with the result
                  $("#title")l(data['title']) ;
               });
               return false ;
            });
         });
      </script>

   </head>

   <body>
      <h1 id = "title">What's your name?</h1>
      <form id = " formtest" action = " #" method = " post">
         <p>
            <label for = " name">Name:</label>
            <input type = " text" id = "name"/> <br/>
            <input type = " submit" value = " Set"/>
         </p>
      </form>
   </body>

</html>

AJAXの関数は<script>タグ内に含まれています。

出力

上記のコードは、次の出力を生成します-

Ajax出力

値がユーザーによって送信されると、AJAX機能が実装され、画面が以下に示すようにフォームにリダイレクトされます-

出力画面

CherryPy-デモアプリケーション

この章では、CherryPyフレームワークでのアプリケーションの作成方法に焦点を当てます。

CherryPyのデモアプリケーション用の Photoblog アプリケーションを検討してください。 Photoblogアプリケーションは通常のブログですが、主要なテキストはテキストの代わりに写真になります。 Photoblogアプリケーションの主な欠点は、開発者が設計と実装にもっと集中できることです。

基本構造–エンティティの設計

エンティティは、アプリケーションの基本構造を設計します。 以下は、フォトブログアプリケーションのエンティティです-

  • Film
  • 写真
  • アルバム

以下は、エンティティの関係の基本的なクラス図です-

基本構造

設計構造

前の章で説明したように、プロジェクトの設計構造は、次のスクリーンショットに示すようになります-

デザイン構造

Photoblogアプリケーションのサブディレクトリがある特定のアプリケーションを検討してください。 サブディレクトリは、photos、Album、Filmで、controllers.py、models.py、server.pyが含まれます。

機能的には、Photoblogアプリケーションは、作成、取得、更新、削除といった従来のCRUDインターフェイスを介してこれらのエンティティを操作するAPIを提供します。

データベースへの接続

ストレージモジュールには一連の操作が含まれます。操作の1つであるデータベースとの接続。

完全なアプリケーションであるため、データベースとの接続は、API、および作成、取得、更新、削除の機能を維持するために必須です。 

import dejavu

arena = dejavu.Arena()
from model import Album, Film, Photo
def connect():

conf = {'Connect': "host=localhost dbname=Photoblog user=test password=test"}
arena.add_store("main", "postgres", conf)
arena.register_all(globals())

上記のコードの領域は、基盤となるストレージマネージャーとビジネスロジック層の間のインターフェイスになります。

接続関数は、PostgreSQL RDBMSのアリーナオブジェクトにストレージマネージャーを追加します。

接続が取得されると、ビジネス要件に従ってフォームを作成し、アプリケーションの動作を完了することができます。

アプリケーションを作成する前に最も重要なことは、*エンティティマッピング*とアプリケーションの構造の設計です。

CherryPy-テスト

テストは、アプリケーションをさまざまな観点から実施するためのプロセスです-

  • 問題のリストを見つける
  • 期待される結果と実際の結果、出力、状態などの違いを見つける
  • 実装フェーズを理解します。
  • 現実的な目的に役立つアプリケーションを見つけます。

テストの目的は、開発者に責任を負わせることではなく、ツールを提供し、特定の時間にアプリケーションの状態を推定するための品質を向上させることです。

テストは事前に計画する必要があります。 これには、テストの目的を定義し、テストケースの範囲を理解し、ビジネス要件のリストを作成し、プロジェクトのさまざまなフェーズに伴うリスクを認識する必要があります。

テストは、システムまたはアプリケーションで検証されるさまざまな側面として定義されます。 以下は*一般的なテストアプローチ*のリストです-

  • ユニットテスト-これは通常、開発者自身によって実行されます。 これは、コードの単位が期待どおりに機能するかどうかを確認することを目的としています。
  • ユーザビリティテスト-開発者は通常、システムの知識がないエンドユーザー向けのアプリケーションを作成していることを忘れる場合があります。 ユーザビリティテストは、製品の長所と短所を検証します。
  • 機能/受け入れテスト-ユーザビリティテストでは、アプリケーションまたはシステムが使用可能かどうかを確認しますが、機能テストでは、指定されたすべての機能が実装されていることを確認します。
  • 負荷およびパフォーマンステスト-これは、システムが実行される負荷およびパフォーマンステストに調整できるかどうかを理解するために実行されます。 これは、ハードウェアの変更、SQLクエリの最適化などにつながる可能性があります。
  • 回帰テスト-製品の連続リリースが以前の機能を破壊しないことを検証します。
  • 信頼性と回復力のテスト-信頼性のテストは、1つまたは複数のコンポーネントの内訳でシステムアプリケーションを検証するのに役立ちます。

単体テスト

フォトブログアプリケーションは、常に単体テストを使用して以下を確認します-

  • 新しい機能は、期待どおりに正しく機能します。
  • 既存の機能は、新しいコードリリースによって壊れることはありません。
  • 欠陥は修正され、修正されたままです。

Pythonには、単体テストへの異なるアプローチを提供する標準の単体テストモジュールが付属しています。

単体テスト

unittestは、Kent BeckとErich Gammaによって開発されたJava単体テストパッケージであるJUnitに根ざしています。 単体テストは、定義されたデータを返すだけです。 モックオブジェクトを定義できます。 これらのオブジェクトを使用すると、アプリケーション全体に依存することなく、設計のインターフェイスに対してテストできます。 また、他のテストが含まれる分離モードでテストを実行する方法も提供します。

次の方法でダミークラスを定義しましょう- 

import unittest

class DummyTest(unittest.TestCase):
def test_01_forward(self):
dummy = Dummy(right_boundary=3)
   self.assertEqual(dummy.forward(), 1)
   self.assertEqual(dummy.forward(), 2)
   self.assertEqual(dummy.forward(), 3)
   self.assertRaises(ValueError, dummy.forward)

def test_02_backward(self):
dummy = Dummy(left_boundary=-3, allow_negative=True)
   self.assertEqual(dummy.backward(), -1)
   self.assertEqual(dummy.backward(), -2)
   self.assertEqual(dummy.backward(), -3)
   self.assertRaises(ValueError, dummy.backward)

def test_03_boundaries(self):
dummy = Dummy(right_boundary=3, left_boundary=-3,allow_negative=True)
   self.assertEqual(dummy.backward(), -1)
   self.assertEqual(dummy.backward(), -2)
   self.assertEqual(dummy.forward(), -1)
   self.assertEqual(dummy.backward(), -2)
   self.assertEqual(dummy.backward(), -3)

コードの説明は次のとおりです-

  • unittestモジュールをインポートして、指定されたクラスの単体テスト機能を提供する必要があります。
  • クラスは、unittestをサブクラス化して作成する必要があります。
  • 上記のコードのすべてのメソッドは、単語のテストで始まります。 これらのメソッドはすべて、unittestハンドラーによって呼び出されます。
  • assert/failメソッドは、例外を管理するためにテストケースによって呼び出されます。

テストケースを実行するための例としてこれを考慮してください- 

if __name__ == '__main__':
unittest.main()

テストケースを実行するための結果（出力）は次のようになります- 

----------------------------------------------------------------------
Ran 3 tests in 0.000s
OK

機能テスト

アプリケーションの機能が要件に従って形になり始めたら、一連の機能テストにより、仕様に関するアプリケーションの正確性を検証できます。 ただし、Seleniumなどのサードパーティ製品の使用を必要とするパフォーマンスを向上させるために、テストを自動化する必要があります。

CherryPyは、機能テストの記述を容易にする組み込み関数のようなヘルパークラスを提供します。

負荷テスト

記述しているアプリケーションとボリュームに関する期待に応じて、負荷とパフォーマンスのテストを実行して、アプリケーションが特定レベルのパフォーマンスに達するのを妨げている潜在的なボトルネックを検出する必要があります。

このセクションでは、FunkLoadパッケージに含まれていないため、パフォーマンスまたは負荷テストの実行方法について詳しく説明しません。

FunkLoadの非常に基本的な例は次のとおりです- 

from funkload.FunkLoadTestCase
import FunkLoadTestCase

class LoadHomePage(FunkLoadTestCase):
def test_homepage(self):

server_url = self.conf_get('main', 'url')
nb_time = self.conf_getInt('test_homepage', 'nb_time')
home_page = "%s/" % server_url

for i in range(nb_time):
self.logd('Try %i' % i)
self.get(home_page, description='Get gome page')
if __name__ in ('main', '__main__'):

import unittest

unittest.main()

ここに上記のコードの詳細な説明があります-

  • テストケースはFunkLoadTestCaseクラスを継承する必要があります。これにより、FunkLoadは、テスト中に発生することを追跡する内部ジョブを実行できます。
  • FunkLoadはクラス名に基づいてファイルを検索するため、クラス名は重要です。
  • 設計されたテストケースは、構成ファイルに直接アクセスできます。 Get（）およびpost（）メソッドはサーバーに対して単に呼び出され、応答を取得します。

CherryPy-アプリケーションの展開

この章では、組み込みのCherryPy HTTPサーバーを介して有効化されたCherryPyベースのアプリケーションSSLに焦点を当てます。

設定

Webアプリケーションで必要な構成設定のさまざまなレベルがあります-

  • * Webサーバー*-HTTPサーバーにリンクされた設定
  • エンジン-エンジンのホスティングに関連する設定
  • アプリケーション-ユーザーが使用するアプリケーション

展開

CherryPyアプリケーションの展開は、Pythonシステムパスからすべての必要なパッケージを入手できる非常に簡単な方法と考えられています。 共有Webホスト環境では、Webサーバーはフロントエンドに配置され、ホストプロバイダーがフィルタリングアクションを実行できるようにします。 フロントエンドサーバーは、Apacheまたは lighttpd です。

このセクションでは、Apacheおよびlighttpd Webサーバーの背後でCherryPyアプリケーションを実行するためのいくつかのソリューションを紹介します。 

cherrypy
def setup_app():

class Root:
@cherrypy.expose
def index(self):
   # Return the hostname used by CherryPy and the remote
   # caller IP address

return "Hello there %s from IP: %s " %
(cherrypy.request.base, cherrypy.request.remote.ip)
cherrypy.config.update({'server.socket_port': 9091,
   'environment': 'production',
   'log.screen': False,
   'show_tracebacks': False})

cherrypy.tree.mount(Root())
if __name__ == '__main__':

setup_app()
cherrypy.server.quickstart()
cherrypy.engine.start()

SSL

  • SSL（Secure Sockets Layer）*はCherryPyベースのアプリケーションでサポートできます。 SSLサポートを有効にするには、次の要件を満たす必要があります-
  • PyOpenSSLパッケージをユーザーの環境にインストールする
  • サーバーにSSL証明書と秘密鍵を持っている

証明書と秘密鍵の作成

証明書と秘密鍵の要件に対処しましょう-

  • まず、ユーザーは秘密鍵が必要です-
openssl genrsa -out server.key 2048
  • このキーはパスワードで保護されていないため、保護が弱くなります。
  • 次のコマンドが発行されます-
openssl genrsa -des3 -out server.key 2048
  • プログラムにはパスフレーズが必要です。 OpenSSLのバージョンで空の文字列を提供できる場合は、そうします。 それ以外の場合、デフォルトのパスフレーズを入力し、次のように生成されたキーから削除します-
openssl rsa -in server.key -out server.key
  • 証明書の作成は次のとおりです-
openssl req -new -key server.key -out server.csr
  • このプロセスでは、詳細を入力するように要求されます。 これを行うには、次のコマンドを発行する必要があります-
openssl x509 -req -days 60 -in server.csr -signkey
server.key -out server.crt
  • 新しく署名された証明書は60日間有効です。

次のコードは、その実装を示しています- 

import cherrypy
import os, os.path

localDir = os.path.abspath(os.path.dirname(__file__))
CA = os.path.join(localDir, 'server.crt')
KEY = os.path.join(localDir, 'server.key')
def setup_server():

class Root:
@cherrypy.expose
def index(self):
   return "Hello there!"

cherrypy.tree.mount(Root())
if __name__ == '__main__':

setup_server()
cherrypy.config.update({'server.socket_port': 8443,
   'environment': 'production',
   'log.screen': True,
   'server.ssl_certificate': CA,
   'server.ssl_private_key': KEY})

cherrypy.server.quickstart()
cherrypy.engine.start()

次のステップは、サーバーを起動することです。あなたが成功している場合は、画面に次のメッセージが表示されます- 

HTTP Serving HTTPS on https://localhost:8443/
「https://www.finddevguides.com/index.php?title=Cherrypy-quick-guide&oldid=78762」から取得
Powered by MediaWiki