CherryPy - Services Web

Un service Web est un ensemble de composants Web qui facilite l'échange de données entre l'application ou les systèmes, qui comprend également des protocoles et des normes ouverts. Il peut être publié, utilisé et trouvé sur le Web.

Les services Web sont de divers types comme RWS (RESTfUL Web Service), WSDL, SOAP et bien d'autres.

REST - Transfert d'état de représentation

Type de protocole d'accès distant, qui transfère l'état du client au serveur, ce qui peut être utilisé pour manipuler l'état au lieu d'appeler des procédures distantes.

Ne définit pas de codage ou de structure spécifique et les moyens de renvoyer des messages d'erreur utiles.
Utilise des "verbes" HTTP pour effectuer des opérations de transfert d'état.
Les ressources sont identifiées de manière unique à l'aide de l'URL.
Ce n'est pas une API mais plutôt une couche de transport API.

REST maintient la nomenclature des ressources sur un réseau et fournit un mécanisme unifié pour effectuer des opérations sur ces ressources. Chaque ressource est identifiée par au moins un identifiant. Si l'infrastructure REST est implémentée avec la base de HTTP, ces identifiants sont appelésUniform Resource Identifiers (URIs).

Voici les deux sous-ensembles communs de l'ensemble d'URI -

Sous-ensemble	Forme complète	Exemple
URL	Localisateur de ressources uniformes	http://www.gmail.com/
URNE	Nom de ressource uniforme	urn: isbn: 0-201-71088-9 urn: uuid: 13e8cf26-2a25-11db-8693-000ae4ea7d46

Avant de comprendre l'implémentation de l'architecture CherryPy, concentrons-nous sur l'architecture de CherryPy.

CherryPy comprend les trois composants suivants -

cherrypy.engine - Il contrôle le démarrage / démontage des processus et la gestion des événements.
cherrypy.server - Il configure et contrôle le serveur WSGI ou HTTP.
cherrypy.tools - Une boîte à outils d'utilitaires orthogonaux au traitement d'une requête HTTP.

Interface REST via CherryPy

Le service Web RESTful implémente chaque section de l'architecture CherryPy à l'aide des éléments suivants:

Authentication
Authorization
Structure
Encapsulation
La gestion des erreurs

Authentification

L'authentification aide à valider les utilisateurs avec lesquels nous interagissons. CherryPy comprend des outils pour gérer chaque méthode d'authentification.

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)

La fonction authenticate () ci-dessus aidera à valider l'existence des clients ou des utilisateurs. Les outils intégrés aident à terminer le processus de manière systématique.

Autorisation

L'autorisation aide à maintenir la cohérence du processus via URI. Le processus aide également à transformer les objets par des pistes de jetons utilisateur.

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
})

Les outils d'autorisation intégrés aident à gérer les routines de manière systématique, comme mentionné dans l'exemple précédent.

Structure

Le maintien d'une structure d'API aide à réduire la charge de travail du mappage de l'URI de l'application. Il est toujours nécessaire de garder l'API détectable et propre. La structure de base de l'API pour le framework CherryPy devrait avoir les éléments suivants:

Comptes et utilisateur
Autoresponder
Contact
File
Folder
Liste et champ
Message et lot

Encapsulation

L'encapsulation aide à créer une API légère, lisible par l'homme et accessible à divers clients. La liste des éléments ainsi que la création, la récupération, la mise à jour et la suppression nécessitent l'encapsulation de l'API.

La gestion des erreurs

Ce processus gère les erreurs, le cas échéant, si l'API échoue à s'exécuter à l'instinct particulier. Par exemple, 400 correspond à une demande incorrecte et 403 correspond à une demande non autorisée.

Exemple

Considérez ce qui suit comme exemple d'erreurs de base de données, de validation ou d'application.

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())

Le code ci-dessus produira la sortie suivante -

La gestion de l'API (Application Programming Interface) est facile grâce à CherryPy grâce aux outils d'accès intégrés.

Méthodes HTTP

La liste des méthodes HTTP qui opèrent sur les ressources est la suivante -

S. Non	Méthode et fonctionnement HTTP
1.	HEAD Récupère les métadonnées de la ressource.
2.	GET Récupère les métadonnées et le contenu de la ressource.
3.	POST Demande au serveur de créer une nouvelle ressource à l'aide des données incluses dans le corps de la demande.
4.	PUT Demande au serveur de remplacer une ressource existante par celle incluse dans le corps de la demande.
5.	DELETE Demande au serveur de supprimer la ressource identifiée par cet URI.
6.	OPTIONS Demande au serveur de renvoyer des détails sur les capacités soit globalement, soit spécifiquement pour une ressource.

Protocole de publication Atom (APP)

APP est né de la communauté Atom en tant que protocole de niveau application en plus de HTTP pour permettre la publication et l'édition de ressources Web. L'unité de messages entre un serveur APP et un client est basée sur le format de document XML Atom.

Le protocole de publication Atom définit un ensemble d'opérations entre un service APP et un agent utilisateur utilisant HTTP et ses mécanismes et le format de document XML Atom comme unité de messages.

APP définit d'abord un document de service, qui fournit à l'agent utilisateur l'URI des différentes collections servies par le service APP.

Exemple

Prenons un exemple pour montrer comment fonctionne l'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 spécifie comment effectuer les opérations CRUD de base sur un membre d'une collection ou la collection elle-même à l'aide des méthodes HTTP comme décrit dans le tableau suivant -

Opération	Méthode HTTP	Code d'état	Contenu
Récupérer	AVOIR	200	Une entrée Atom représentant la ressource
Créer	PUBLIER	201	L'URI de la ressource nouvellement créée via les en-têtes Location et Content-Location
Mise à jour	METTRE	200	Une entrée Atom représentant la ressource
Supprimer	SUPPRIMER	200	Aucun

↰ Previous page Next page ↱

CherryPy - Services Web

REST - Transfert d'état de représentation

Interface REST via CherryPy

Authentification

Autorisation

Structure

Encapsulation

La gestion des erreurs

Exemple

Méthodes HTTP

Protocole de publication Atom (APP)

Exemple

Tutoriel CherryPy