Affichage des articles dont le libellé est architecture. Afficher tous les articles
Affichage des articles dont le libellé est architecture. Afficher tous les articles

jeudi 1 mai 2014

Pour bien commencer avec les Architectures REST ou RESTFUL

La vague  REST va déferler sur nous. Hélas, la encore des marchands de rêve vont chercher à vous vendre du REST au kilo.

Ce qu'il faut bien  comprendre: Les architectures REST devront être une CONSÉQUENCE de l'évolution de vos applications  et non pas une CAUSE d'évolution de celles-ci.
En clair: commencer par mette du REST sans avoir ce qui va avec, mettra en difficulté votre système informatique, vos équipes etc.

Pour commencer le REST (ou RESTFUl ) c'est quoi ?


«Fielding, Roy Thomas. Architectural Styles and the Design of Network-based Software Architectures. Doctoral dissertation, University of California, Irvine, 2000.»

Un chapitre ici traduit en français. (Le 5eme : un des plus important)
  • C'est un livre de chevet (publié en 2007) :lien ici 

Couverture ( observez qui à donné son avis sur le livre)


(selfie truqué : pourquoi ? : à vous de trouver l'erreur)



  • C'est une série de principe : 


1) Utilisation des verbes (Méthodes) du HTTP.
GET : lire une ressource
DELETE : supprimer une ressource
POST et PUT: pour creer ou modifier une ressource
(ou inversement : l'idée est d avoir un verbe pour créer différent de celui utiliser pour modifier)

source stackoverflow: http://stackoverflow.com/questions/630453/put-vs-post-in-rest

2) Chaque ressource a son URL. On interagit avec les ressources en combinant les  url avec les methodes HTTP.

  • GET http://www.example.com/customers/12345
  • GET http://www.example.com/customers/12345/orders
  • GET http://www.example.com/buckets/sample
  • PUT http://www.example.com/customers/12345
  • PUT http://www.example.com/customers/12345/orders/98765
3) Pas de session gérée  coté serveur : Toute l'information de session est stockée sur le client ET donc chaque requête est autonome et complète.

4) Le serveur applicatif ne sert qu'a délivrer de la donnée (le plus souvent au format JSON et non plus XML)

Voila le rapidement présenté le  REST.

Pourquoi le REST a-t-il le vent en poupe ?

  • Il permet de répartir les coûts d'infrastructure entre le fournisseur de ressource (service) et l'utilisateur (poste client). Il est donc pleinement compatible avec le modèle économique des clouds. Les traitements coûteux en CPU  (assemblages des pages WEB, manipulation des donnée)  sont réalisés sur la machine du client. 
  • Les infrastructures et les applications sont plus simples: pas besoin d'avoir des serveurs de session, des bus d'entreprise etc. 
  • La scalabilité est linéaire: sans partage de session à prévoir, avec des serveurs à gestion d 'événement (Node.js , nginx) , l'ajout d'un serveur augmente surement le nombre de connexion possible.
  • Il met fin au débat entre les langages et les framework : PHP ,Java, Spring, Express, Rails  :La partie serveur ne sert qu'a délivrer de la donnée JSON. Le seul langage à maîtriser vraiment est le Javascript (le seul langage universel pour le navigateurs). Aussi, si vous n'avez pas les ressources de développement aguerries au Javascript l'adoption du  REST sera difficile.

Aussi mettre en place du REST sans avoir un idée de la stratégie à mettre en place coté client (Angular, Backbone , Ember ?...) c'est prendre le sujet à l'envers.

Comment reconnaître le vrai du faux REST.


Le critère de la session gérée coté client est important, sinon le simple test suivant est suffisant :

Est ce que votre application fonctionne avec le simple client HTTP en ligne de  commande CURL ?

Ex :  curl -X DELETE http://localhost:4567/pgm/5352d84751514034cc000048

(la partie serveur qui répond à la requete)
## Restful uri

##
delete '/pgm/:id'  do
@id_pgm =  params[:id]
@pgm =  @db['pgm'].remove('_id'  => BSON::ObjectId(@id_pgm) )
response.write ("{ok}")
end




















lundi 3 février 2014

La scalabilité dans un fauteuil avec phusion passenger

Lors de la  mise en place d'architecture à base de Node.js, les mêmes questions reviennent:
Comment superviser des applications sous node.js ?
La réponse habituelle est FOREVER : forever permet de lancer un programme sous node.js et de le relancer si besoin.
Sur une machine multi-processeur, il est fréquent lancer plusieurs instances de l'applications sous node.js.
Node.js étant monoprocesseur (monothreading) il restera cantonné sur un CPU.

Je lance donc plusieurs instances de node.js (1 par CPU) par la commande forever.
Dans le cas où on dispose de plusieurs serveur (physique ou VM ) , il est d'usage de placer un serveur web NGINX en frontal qui fera office de reverse proxy.

On obtient les architectures suivantes:

(voir article sur ce lien)

Se pose alors le problème de supervision générale du système.
Pour ma part, je lance un 'agent' sur chaque serveur qui renseigne en temps reel sur les instances Node.js qui tournent sur un serveur.

Ce programme en coffeescript lance la commande forever avec l'option list  (lignes 22 à 28) et 'compte' le nombre de ligne retournée (lignes 9 à 19) .
Ce dispositif accessible par une API REST (lignes 30 à 35 )permet de construire des interfaces graphiques de supervision:

Avec le résultat suivant :

Tout ceci est à faire manuellement.

Est ce que je suis le seul à avoir ces problèmes ?: NON répond Hongli LAI à la conférence Dot.js de Paris: (video sur ce lien )



Il reprend les différentes étapes de construction d'un projet Node.js


forever forever...

Puis faire démarrer le tout


Mettre en serveur Nginx en reverse proxy


Mettre plusieurs instances en cluster

Et monitorer l'ensemble

Ces dispositifs sont utilisés chez quelques PME : Apple, Pixar, New York Times, AirBnB, Juniper etc.. et  over 350.000 websites.

Ce montage en couche peut être remplacé par 1 seul composant : phusion passenger

phusion passenger fournit les informations suivantes: 


Lancement des Node.js : phusion passenger se charge de lancer le nombre d'instance qu'il faut et d'équilibrer leur charge. 

Reverse proxy

Supervision: à la place d'une supervision à programmer , la ligne de commande phusion passenger retourne les informations suivantes.

$ passenger-status
Version : 4.0.37
Date    : 2013-11-14 21:55:30 +0100
Instance: 25002
----------- General information -----------
Max pool size : 6
Processes     : 1
Requests in top-level queue : 0

----------- Application groups -----------
/Users/phusion/nodetestapp#default:
  App root: /Users/phusion/nodetestapp
  Requests in queue: 0
  * PID: 25012   Sessions: 0       Processed: 2       Uptime: 9s
    CPU: 0%      Memory  : 14M     Last used: 3s ago

Phusion passenger fonctionne soit tout seul ,  integré avec nginx ou encore avec apache.



Avec Node.js les architectures sont encore plus simples , plus performantes  plus robustes et moins chères.


vendredi 2 août 2013

Architectures orthogonales

J'ai entendu une fois l'expression 'architectures orthogonales'  sans avoir plus de détail.
En piochant à droite et à gauche, on imagine que cette notion fait référence aux des
 architectures verticales et horizontales.

Le modèle 3tiers

On a d'un coté des modèles d'infrastructure en 'tiers' avec généralement 3 tiers:
Le serveur web , le serveur de traitement (applicatif) et le serveur de données (SGBD) .

La conception MVC

A cette spécialisation  des rôles  s'ajoute un découpage fonctionnel en couche MVC 

Le serveur applicatif met en oeuvre un ensemble de design pattern: Model Vue Contrôleur (inventé bien avant le WEB) 


Et le reste: OOP , OS

A ce mille-feuille vient s'ajouter les couches liées au développement en approche objet puis celles du système d'exploitation.

Et donc..

On se retrouve avec un empilement de module , de composant de nature et de taille hétérogène.

Or quel est l'objectif:  Offrir un service de qualité à nos utilisateurs. Ici intervient la notion de scalabilité. Comment supporter un nombre d'utilisateur plus important avec des volumes de données en hausse ?.
A chaque fois le problème est botté en touche en direction des  responsables d'infrastructure. 
Leur  seule  réponse possible est  d'augmenter le nombre de serveur pour doubler, tripler les composants. 
Mais empiler des briques hétérogènes fragilise la stabilité de l'ensemble. C'est coûteux pour un rendement marginal décroissant.  Car cet empilement ne donne pas un rendement d’échelle linéaire
Il faut trouver des systèmes pour partager des sessions serveurs , gérer des caches à tous les niveaux, des répartiteurs etc.  bref le prix à payer est élevé. 

La scalabilité horizontale consiste à augmenter le nombre de machine. La scalabilité verticale vise à augmenter la puissance unitaire des machines.  L'orthogonalité cherche à combiner les deux approches en par une simplification des architectures.



Vers des architectures pus simples et ... moins coûteuses.


La première règle à mettre à oeuvre est de réaliser des applications avec des architectures simples avec moins de couche.

Règle 1: simplifier les couches d'abstraction: chaque abstraction coûte et ajoute de la  complexité  
  
Avez vous besoin de faire une application métier de gestion ou un site de publication ?
Si la réponse est 'une application métier' , vous n'avez pas besoin d'un serveur web complet pour votre application.  
Votre choix doit se tourner vers des serveurs applicatifs à gestion d’événement non bloquants et asynchrone  (Non-bloking I/O event loops) comme Node.js pour javascript , VertX pour Java ou eventmachine pour ruby.
Et des mico-frameworks comme Express ou Sinatra

Dans ces technologies , le développeur  travaille directement son cœur de métier: la mise à disposition de ressources. Il n'est plus tributaire de la configuration lourde d'un serveur HTTP.
Un process en attente sur un serveur =  gaspillage de ressource = les serveurs vous font les poches.  

Règle 2: Réfléchir en terme de conteneur autonome. 

Votre application doit être l'assemblage de briques identiques autonomes. Ces briques ne doivent pas gérer ou partager des sessions. Celles ci sont prises en charge par le client (REST: les requêtes sont autonomes
Ce qui implique aussi que chaque conteneur accèdes à des données dans son contexte. 
Aussi un conteneur embarque : une couche HTTP, l'application métier et le backend de stockage.

Comment passer d'une architecture 'classique' à une architecture moderne. 


  • Tout d'abord la partie applicative:




  • Puis la partie frontale :


Pour accéder aux conteneur, il est possible de placer en frontend le serveur NGINX. Ici ,il n'est pas utilisé comme un serveur web mais comme un reverse-proxy avec des fonctionnalités de répartition de charge.




  • La partie backend ou stockage:

L'usage d'une base NoSQL viendra compléter le dispositif et rendra chaque 'nœud' autonome les uns par rapport aux autres.


  •  La partie SSO  peut elle aussi être implémentée sur chaque nœud: 


  

Ici , il n'est plus question de SSO préemptif ou coopératif: on est dans un mode de micro-SSO 

Pour aller plus loin.


L'idée générale est d'obtenir des boites identiques autonomes un peu comme ceci :


Permettant empilements à la fois verticaux et horizontaux = Orthogonaux  = des constructions solides.



mardi 22 novembre 2011

Le prochain défi du SSO ( signle sign on): faire simple

Le principe du SSO date maintenant d'une bonne dizaine d'année. j'ai travaillé sur lemonldap puis le projet lemonldap::NG (NG pour Nouvelle Gendarmerie et non pas Next Generation)  a pris la suite. Mais depuis, il n'y a rien de vraiment innovant dans ce domaine. La gestion d'identité devait etre un élément stratégique pour les editeurs , les frameworks , les entreprises et les fournisseurs d'identité. Tout ça est retombé comme un soufflet à la guimauve. Chacun compte ses pertes sur le champ de bataille. Que reste-t-il de tout ca ?

Les fournisseurs d'identité et les protocoles: les grands vainqueur sont les sites offrant des services d'authentification basés sur le protocole oauth : exit liberty alliance et SAML. Tous les grands sites comme facebook , twitter, google ont emboité le pas à ce protocole.

Les parefeux applicatifs: on reste sur des équipements en frontal à base d'apache ou de  tomcat  (rupture de flux) ou en service de redirection  (CAS).

Le service d'authentification: S'authentifier auprès d'un annuaire LDAP est cohérent dans la mesure où les équipements les plus hétérogènes peuvent dialoguer avec un service LDAP. En revanche , utiliser un annuaire LDAP comme stockage  d'habilitation est une solution  inadaptée.  Une base de données est plus performante pour cela , notament grace à la puissance du SQL.

Devoir utiliser deux systèmes (LDAP et base de données)  pour rendre le service du SSO est génant. Les administrateurs systèmes préfèrent ne gérer qu'un seul type d'équipement. C'est pour cette qu'un système de stockage NoSQL peut tirer son épingle du jeu.

La mise en place d'un SSO au sein d'une entité reste une opération compliquée, intrusive et structurante. Le SSO introduit un point de  fragilité dans les architectures.  Il faut des serveurs , le plus souvent doublés: tout cela coute cher  et rend  les applications interdépendantes.


Les SSO sont des constructions délicates et réservées aux experts. 
Illustration: machine de Rube Golberg

Est ce qu'il ne serait pas possible de faire des systèmes de SSO SIMPLE ? 


La réponse est : OUI

samedi 16 juillet 2011

Un piscine sur les toits

Cet immeuble est un Casino à Singapour (Marina Bay Sands Casino)

Il est déjà d'une forme originale, mais le meilleur se trouve au 57 eme étage: la piscine





Swimming pool in the sky

Il est déconseillé de se plonger au dessus des barrières.

vendredi 23 octobre 2009

Modèle SOA vs ROA

Deux mondes s'affrontent : d'un coté l'informatique en Entreprise de l'autre l'informatique d'Internet destinée à l'utilisateur final.
La frontière n'est pas étanche ,et parfois des technologies se diffuse de part et d'autre, comme par exemple le web 1.0 et les services de messagerie.

Ce schémas illustre mon propos:


soaroa2


Il y a quelques années , le modèle SOA (AOS) était vu comme le modèle qui répondait au mieux au mouvement de la général de mondialisation (globalisation - restructuration ) . Une entreprise X rachetait une entreprise Y , elle devait pouvoir intégrer le système d'information de Y à moindre coût.
Dans un monde SOA , le service informatique 'rentre dans le rang' , il ne dicte plus ses lois (organisation, processus ) au reste des services.
Hélas les retours sur investissement est long ,difficile et hasardeux.

De l'autre coté du fossé , on trouve un autre monde en perpétuelle agitation avec des effets de mode, des coups de poker. Internet est massivement orienté 'ressources' (uri/url ). Plus le système est léger mieux c'est ! (KISS : Keep It Simple and Stupid).

On trouve donc deux philosophie : une prônant les services ,l'autre les ressources :

soavsroa1

L'émergence des frameworks légers (en complexité pas en fonctionnalité offerte) comme Rails ou Django dans un premier temps sur Internet et maintenant dans l'entreprise est un signe fort qui n'est pas neutre dans le choix des statégies à mettre en place.
Les applications RestFull (à base de CRUD , AJAX ) sont les seules à pouvoir offrir à l'entreprise un ROI rapide et sûr. Elles evitent les effets tunnel d'un projet qui sera terminer et qu'il faudra immediatement modifier pour plaquer aux évolutions. Les entreprises doivent se préparer à la vague déferlante du WEB 2.0 dans l'entreprise et commencer à se familiariser avec le SAAS (cloud) qui est massivement SAAR (R comme ressource) .
(ici un comparatif Rails/django ). La cote de popularité des langages illustre mes propos : Javascript à le vent en poupe , ainsi que Python , Ruby et PHP (qui n'a pas encore son killer framework ), alors que JAVA piétine voir le The TIOBE Programming Community index.