Vous êtes sur la page 1sur 373

Spring Boot

Architecture Microservices

BENLAHMAR EL HABIB
Spring Boot
Spring …..
 Spring
Spring CloudSpring Cloud for
Cloud for
Spring Cloud Bus Spring Cloud ...
Cloud Foundry Amazon Web Services

Spring Cloud Config Spring Cloud Netfix Spring Cloud Consul

Spring Cloud Context Spring Cloud Commons

Spring Boot

Spring
Spring Boot
Spring Boot est un Framework qui permet de créer des
applications basées sur des micro services.
Atouts de Spring Boot :
◦ Faciliter le développement d’applications complexes.
◦ Faciliter à l’extrême l’injection des dépendances
◦ Réduire à l’extrême les fichier de configurations
 ◦ Faciliter la gestion des dépendances Maven.
◦ Auto Configuration : la plupart des beans sont créés si le
ou les jar(s) adéquats sont dans le classpath.
◦ Fournir un conteneur de servlet embarqué (Tomcat, Jetty)
 ◦ Créer une application autonome (jar ou war)
L'auto-configuration
Cette fonctionnalité est la plus importante de Spring Boot.
Elle permet de configurer automatiquement votre
application à partir des jar trouvés dans votre Classpath.
En d'autres termes, si vous avez importé des dépendances,
Spring Boot ira consulter cette liste puis produira la
configuration nécessaire pour que tout fonctionne
correctement.

@EnableAutoConfiguration ou @SpringBootApplication
Avec cette annotation, Spring Boot ira scanner la liste de vos
dépendances, trouvant par exemple Hibernate. Ayant constaté
que vous n'avez défini aucun autre datasource, il créera la
configuration nécessaire et l'ajoutera à ApplicationContext.
Les Starters
Les starters permettent d'importer un ensemble de
dépendances selon la nature de l'application à
développer afin de démarrer rapidement.
Ceci va vous permettre de créer un "squelette" prêt à
l'emploi très rapidement.
L'autre énorme avantage est la gestion des versions. 
Starters
 Prenons l'exemple où vous souhaitez créer un
Microservice. En temps normal, vous aurez besoin des
dépendances suivantes :
 Spring ;
 Spring MVC ;
 Jackson (pour json) ;
 Tomcat ;
 ...
 Avec Spring Boot, vous allez tout simplement avoir une
seule dépendance dans votre pom.xml :
<dependency>
<groupId>org.springframework.boot</groupId
>
<artifactId>spring-boot-starter-
web</artifactId>
</dependency>
Pour les versions
en haut du pom.xml,

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.9.RELEASE</version>
</parent>
Quelques exemples de starters
spring-boot-starter-mail : pour les applications et
services d'envoi de mails.
spring-boot-starter-thymeleaf : si vous souhaitez créer
une application qui offre une interface utilisateur en
utilisant le moteur de template thymeleaf.
spring-boot-starter-web-services : pour les services
plus classiques utilisant SOAP.
Création d’un projet
Actuator
Spring Boot met à disposition des opérationnels, des métriques qu’ils
peuvent suivre une fois l’application déployée en production. Pour
cela Spring Boot utilise « Actuator » qui est un système qui permet
de monitorer une application via des URLs spécifiques ou des
commandes disponibles via SSH.
Sachez, qu’il est possible de définir vos propres indicateurs très
facilement.
Voici une liste non exhaustive des indicateurs disponibles par défaut :
metrics: métriques de l’application (CPU, mémoire, …)
beans: liste des BEANs Spring
trace: liste des requêtes HTTP envoyées à l’application
dump: liste des threads en cours
health: état de santé de l’application
env: liste des profils, des propriétés et des variables d’environnement
Types d’application
Lorsque vous créez le projet  Spring Boot avec
l'option  "Packaging = War", Eclipse créera deux classes
telles que  "AbcApplication & ServletInitializer" pour
vous. Les fichiers  WAR conviennent à être déployé
(deploy) sur des  Web Server.
si vous créez un projet Spring Boot avec le choix
" Packaging = Jar", une seule classe  AbcApplication sera
créée. Lorsque l'application Spring Boot est compressée
dans le fichier JAR, elle peut être exécutée
indépendamment sans être déployée sur un Web Server.
Mais le fichier JAR ne peut pas être déployé sur les Web
Server.
Types
Si vous disposez une application  Spring
Boot disponible, vous devez simplement changer la
méthode d'emballage (Packaging) en WAR :
E-Store

Mini Projet
Exemple d’un e-store : Couches
AccountController CartController

Default
SignOut SignIn Search Category Items Item Shopping Help Error
Details Cart
Presentation
Layer

Check Order Order Order


My Edit Create
out Billing Shipping Process
Account Account Account

Account Profile Product Item Inventory Cart OrderInsert OrderRead


Business
Logic
Layer

IAccount IProfile IProduct IItem IInventory IOrder


Data
Access
Layer
Exemple d’un e-store : Domaines

Default
SignOut SignIn Search Category Items Item Shopping Help Error
Details Cart
Presentation
Layer

Check Order Order Order


My Edit Create
out Billing Shipping Process
Account Account Account

Account Profile Product Item Inventory Cart OrderInsert OrderRead


Business
Logic
Layer

1.0 1.0 10.0 5.1 1.0


1.1 2.0 11.2 5.2 6.0
1.2 3.5 11.5 5.3 7.0
IAccount IProfile IProduct IItem IInventory IOrder
Data
Access
Layer

Customer Catalog Inventory Shopping Billing


Exemple d’un e-store : Domaines

Presentation
Layer

Business
Logic
Layer

Data
Access
Layer

Customer Catalog Inventory Shopping Billing


Exemple d’un e-store : Services

Presentation
Layer

Business
Logic
Layer

Service Manage Show Make


Layer Shop Bill
Customer Catalog Inventory

Data
Access
Layer
Spring Data
Introduction
Travailler dans les deux univers que sont l'orienté objet
et la base de données relationnelle peut être lourd et
consommateur en temps dans le monde de l'entreprise
d'aujourd'hui.
Hibernate est un outil de mapping objet/relationnel
pour le monde Java.
Le terme mapping objet/relationnel (ORM) décrit la
technique consistant à faire le lien entre la
représentation objet des données et sa représentation
relationnelle basée sur un schéma SQL.
Première approche de l’architecture
d’Hibernate
 Hibernate permet d’assurer la persistance
des objets de l’application dans un
entrepôt de données.
 Cet entrepôt de données est dans la
majorité des cas une base de données
relationnelle, mais il peut être un fichier
XML.
 Le mapping des objets est effectuée par
Hibernate en se basant sur des fichiers de
configuration en format texte ou souvent
XML.
Architecture
Architecture
 L'architecture complète abstrait l'application des APIs JDBC/JTA sous-jacentes
et laisse Hibernate s'occuper des détails.
Mapper une classe
 Supposant que nous avons besoin de
gérer la participation des personnes à
des réunions.
 Une personne participe à plusieurs
réunions et chaque réunion concerne
plusieurs personnes.
 On va s’intéresser tout d’abord au cas
d’une classe et par la suite nous
reviendrons sur le mapping des
associations entre les classes.
Associations
Association
Une association peut être uni- ou bi-directionnelle
Cardinalités: 1-1, 1-N, N-1, M-N
Elles sont définies grâce à une annotation sur la
propriété correspondante

Support de Collection, Set, List, Map


Associations bidirectionnelles
Le développeur est responsable de la gestion des deux
bouts de l’association
Un des bouts est le propriétaire de l'association
Propriétaire
‣ pour les associations autres que M-N, ce bout
correspond à la table qui contient la clé étrangère qui
traduit l’association
‣ pour les associations M-N, le développeur choisit le
bout propriétaire (de manière arbitraire)
‣ l’autre bout (non propriétaire) est qualifié par l’attribut
mappedBy qui donne le nom de l’association
correspondante dans le bout propriétaire
Association 1-1
Annotation @OneToOne
Représente la clé étrangère dans la table
Associations 1-N et N-1
Annotations @OneToMany et @ManyToOne
Représentée par une clé étrangère dans la table qui
correspond au côté propriétaire (obligatoirement le
côté Many)
@ManyToOne
N-1 et 1-N
 Exemple 1

‣ Entité Client
@OneToMany(mappedBy=”client”)
public Set commandes;
‣ Entité Commande
@ManyToOne
public Client client;
 Exemple 2

‣ Entité Client
@OneToMany(mappedBy=”client”, cascade=ALL)
public Set commandes;
‣ Entité Commande
 @ManyToOne
 @JoinColumn(name=”client_id”)
 public Client client;
Associations M-N
Annotation @ManyToMany
Représentée par une table association
Les valeurs par défaut
‣ le nom de la table association est la
concaténation des 2 tables, séparées par _
‣ les noms des attributs clés étrangères sont les
concaténations de la table référencée, de _ et de
l’attribut Id de la table référencée
M-N
M-N
Si le mapping par défaut ne convient pas, on peut le
surcharger avec l’annotation @JoinTable
L’autre côté doit toujours comporter l’attribut
mappedBy
@JoinTable
‣ donne des informations sur la table association
qui va représenter l’association
‣ attribut name donne le nom de la table
‣ attribut joinColumns donne les noms des
attributs de la table qui référencent les clés
primaires du côté propriétaire de l’association
‣ attribut inverseJoinColumns donne les noms des
attributs de la table qui référencent les clés
primaires du côté qui n’est pas propriétaire de
l’association
Collections de types simples
Collections de types embeddable
Niveaux multiples
Embeddable avec associations
Listes triées
Map
Comportement
Comportement
Persistance des entités associées
‣ lorsqu’un objet o est rendu persistant, les objets référencés par o
devraient être rendus persistants
‣ persistance par transitivité
‣ comportement logique, mais…
‣ complexe !
 cohérence
 par exemple, que se passe-t-il si un objet supprimé est référencé
par un autre objet ?
‣ JPA n’effectue pas de persistance par transitivité par défaut
 plus de souplesse
 possibilité d’avoir la persistance par transitivité avec cascade
Comportement
Attribut cascade
‣ permet de propager les effets d’une opération sur les
entités associées
‣ valeurs possibles:
 DETACH , PERSIST, REMOVE, REFRESH, MERGE,
ALL
‣ @OneToMany(cascade=CascadeType.PERSIST)
Par défaut, aucune opération n’est appliquée
transitivement En JPA 2.0, suppression automatique des
orphelins
‣ @OneToMany(cascade=CascadeType.PERSIST,
orphanRemoval=true)
Comportement
Récupération des entités associées
‣ lorsqu’une entité est récupérée (requête), est-ce qu’on
récupère aussi les entités associées ?
‣ et si on récupère les entités associées, est-ce que l’on
récupère les entités associées des entités associées ?
‣ et si… !
JPA laisse le choix de récupérer ou non les entités
associées
‣ on peut choisir le mode de récupération: LAZY ou
EAGER
‣ EAGER: immédiat
‣ LAZY: à la demande
Comportement
LAZY
‣ pour les associations avec des hiérarchies importantes
‣ dans ce cas, l’entité associée n’est pas récupérée
immédiatement
‣ JPA remplace l’entité par un proxy qui permettra de
récupérer l’entité plus tard si besoin
‣ le proxy contient la clé primaire
Par défaut
‣ JPA est en mode EAGER pour 1-1 et N-1
‣ JPA est en mode LAZY pour 1-N et M-N
Héritage
Entités et héritage
Les entités supportent
 L’héritage de classe
 Les associations polymorphiques
 (qui pointe sur un type parent d’une hiérarchie)
 Les requêtes polymorphiques
 (qui retournent différent types d’une hiérarchie)
 (qui retourne un sous-type d’une hiérarchie)
 Une entités peut étendre une classe non entité
 Une classe non entité peut étendre une classe entité
 Une entité peut être abstraite
Entités abstraites
Une classe entity peut être marqué « abstract »
 Une entité abstraite est comme une entité concrète
 Mais elle ne peut pas être instancié !
 Elle peut être employé dans une requête
 La requête retourne des types concrets
Exemple entité abstraite
Mapped superclasses
 Permet d’hériter d’une classe
 Dont des états doivent être persistant
 Mais qui ne doit pas être une entité
 Décorer avec
 javax.persistence.MappedSuperclass:
 Ce type de classe ne peut pas
 Etre dans une requête
 Être demandé a l’EntityManager ou dans une Query
 Il faut utiliser l’entity enfant
 Etre la cible d’une association d’une autre entité
 Il n’y a pas de table correspondant dans la DB
Exemple Mapped Superclasses
Superclasses non-entités
Une entités peut hériter d’une classe non
entité
 La supeclass peut être concrète ou
abstraite
 L’état de la superclass est alors non
persistant
 La superclasse ne peut pas
 Etre utilisé dans l’EntityManager, une
requête
Stratégies d’héritage
1. Une table par hiérarchie
2. Une table par entité concrète de la hiérarchie
1. La table contient les propriété de la classe, et
des classes parent
3. Une table par classe de la hiérarchie
1. La table contient uniquement les propriétés de
la classe
2. Il faut faire un « JOIN » pour obtenir toutes les
propriétés
Definir la strategie d’heritage
Utiliser @Inheritance
 import javax.persistence.InheritanceType;

Strategie par défaut


 InheritanceType.SINGLE_TABLE;
Single Table
InheritanceType.SINGLE_TABLE
 Toutes les instances d’une hiérarchie sont dans une
seule et même table
 La table contient une colonne supplémentaire
discriminant
 Peut être définit par une annotation
Single Table
Avantages
 Bon support pour les associations et les requetes
polymorphiques
 Inconvénients
 Les colonnes doivent être nullable
 Peut contenir beaucoup de valeurs null.
Exemple
Une table par classe concrete
 InheritanceType.SINGLE_TABLE
 Chaque classe concrète a sa propre table
 Chaque table contient toutes les
propriétés (y compris des superclasses)
Une table par classe concrete
 Avantages
 Diminue les valeurs nulles
 Inconvénients
 Mauvais support du polymorphisme
 Des join sur les tables sont requis
 Cette stratégie est optionnel
 Elle n’est pas supporté par toutes les
implémentation de JPA
Exemple
Strategie « JOINED »
InheritanceType.JOINED,
 La classe racine de la hiérarchie a sa propre
table
 Chaque sous-classe a sa table
 Une table ne contient que les propriétés
de la classe
Strategie « JOINED »
 Avantages
 Bon support pour les associations et les requêtes
polymorphiques
 Pas de valeurs nulles superflues
 Inconvénients
 Des join sont requis pour obtenir un objet
 Peut entrainer des mauvaises performances
 Les classes peuvent nécessiter une colonne discriminant
 Dépend de l’implémentation
 Pas un problème si on laisse la création de table auto
Exemple
Remarque
l’annotation @DiscriminatorColumn dans la super-
classe permet de surcharger le nom de la colonne du
discriminant.

(valeur par défaut : «  DiscriminatorType.STRING  »)


AttributeOverrides
lesannotations @AttributeOverrides et @AttributeO
verride permettent de surcharger le mapping des
champs déclarés la super-classe :
Exemple
Exemple 2
Exemple 3
Héritage
Spring Data

Spring Data Spring Data Spring Data Spring Data


JPA Neo4j MongoDB Gemfire

Spring Data Commons

71 10/10/2021
Spring Data JPA
Manipule
JPA Spring Data

Se base sur

Hibernate EclipseLink …

JDBC

BDD

72 10/10/2021
Spring Data JPA
Pour l'intégrer, il suffit d'ajouter une dépendance dans
Maven:
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>1.2.0.RELEASE</version>
</dependency>
En spring boot
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

73 10/10/2021
Spring Data JPA
Principe de base
Pour écrire le DAO pour un type d’entités, il faut
étendre certaines interfaces fournies par Spring Data :
public interface PersonneDao extends CrudRepository<Personne, Long>
{

Nom de l'entité qu'on manipule

Type de l'identifiant de l'entité

74 10/10/2021
Spring Data JPA
Spring Data Commons
Repository Pas de méthode

CrudRepository save(S), findOne(ID), exists(), findAll(), deleteAll(), …

PagingAndSortingRepositor
findAll(Sort), findAll(Pageable)
y

JpaRepository flush(), saveAndFlush(T), deleteInBatch(Iterable<T>), …

Spring Data JPA


75 10/10/2021
API  CRITERIA
L’API Java Persistence Criteria est utilisé pour définir
des requêtes dynamiques à travers la construction
d’objets basés sur la définition de requêtes objets, 

L’API de critères a été ajouté dans JPA 2.0.


Les supports de de suppression et de mise à jour de
l’API de critères ont été ajouté dans JPA 2.1.
l’API Criteria
l’interface principale dans l’API Criteria est
CriteriaBuilder
 Un CriteriaBuilder est obtenu à partir d’un
EntityManager ou un EntityManagerFactory à l’aide
de l’API getCriteriaBuilder ().

CriteriaBuilder qb = entityManager.getCriteriaBuilder();

CriteriaBuilder est utilisé pour construire des objets de


CriteriaQuery et leurs expressions.
l’API Criteria
createQuery () – Crée un CriteriaQuery.
CreateQuery (Classe) – Crée un CriteriaQuery utilisant des
génériques pour éviter le casting du résultat de la classe.
createTupleQuery () – Crée un CriteriaQuery qui retourne « un
map » comme des Tuples d’objets , à la place de l’objet
tableaux pour les requêtes multiselect.
createCriteriaDelete (Classe) – Crée un CriteriaDelete
supprimer un lot d’objets directement sur la base de données
(JPA 2.1).
createCriteriaUpdate (Classe) – Crée un CriteriaUpdate
permet de mettre à jour un lot d’objets directement sur la base
de données (JPA 2.1).
Exemple
API  CRITERIA: Interface hierarchy of query expressions
l’API Criteria
CRITERIA QUERY
CriteriaQuery définit les requêtes de Sélection de base
de données. CriteriaQuery modélise toutes les clauses
de requête select JPQL.
Options
CriteriaQuery définit les clauses et les options suivantes:
distinct (booléen) – Définit si la requête doit filtrer les résultats en
double (faux par défaut). Si une jointure de relation de collection
est utilisée, distinct doit être utilisé pour éviter des résultats en
double.
From (Class) – Définit et renvoie un élément de la requête comme
une clause de la classe d’entité. Au moins un élément est nécessaire
pour que la requête soit valide.
From (EntityType) – Définit et renvoie un élément de la requête
comme une clause du méta-modèle de type entité. Au moins un
élément est nécessaire pour que la requête soit valide.
Select (Selection) – Définit la clause select de la requête. S’il n’est
pas défini, la première racine sera sélectionnée par défaut.
Options
Multiselect (Selection…), multiselect (List<Selection>) – Définit une requête
de sélections multiples.
Where (Expression), where (Predicate…) – Définit la clause where de la
requête. Par défaut toutes les instances de la classe sont sélectionnées.
orderBy (Order…), orderBy (List<Order>) – Définit la clause order de la
requête. Par défaut, les résultats ne sont pas ordonnés.
groupBy (Expression…), groupBy (List<Expression>) – Définit la
clause group de la requête. Par défaut, les résultats ne sont pas regroupés.
Having (Expression), having (Predicate…) – Définit la clause having de la
requête. Having permet de filtrer les résultats regroupés.
subquery(Class) – Crée une sous-requête qui est utilisé dans l’une des autres
clauses.
FONCTION D’AGGREGATION
max (Expression) – Retourne la valeur maximale de tous les résultats.
Il est utilisé pour les types numériques.
Greatest (Expression) – Retourne la valeur maximale de tous les
résultats.
Il est utilisé pour les types non-numériques.
Min (Expression) – Retourne la valeur minimale de tous les résultats.
Il est utilisé pour les types numériques.
Least (Expression) – Retourne la valeur minimale de tous les résultats.
Il est utilisé pour les types non-numériques.
Avg (Expression) – Retourne la moyenne des résultats. Un type
Double est retourné.
FONCTION D’AGGREGATION
Sum (Expression) – Retourne la somme des résultats.
sumAsLong (Expression) – Retourne la somme des
résultats. Un type Long est retourné.
sumAsDouble (Expression) – Retourne la somme des
résultats. Un type Double est retourné.
Count (Expression) – Retourne le nombre d’éléments de
l’ensemble des résultats. Les valeurs NULL ne sont pas
comptées. Un type Long est retourné.
countDistinct (Expression) – Retourne le nombre d’éléments
de l’ensemble des résultats distincts. Les valeurs NULL ne
sont pas comptées. Un type Long est retourné.
CriteriaQuery encapsule les clauses d'une requête
traditionnelle
Exemple (parameter)
Avec JPQL
SELECT c FROM Country c WHERE c.population > :p

Avec criteria
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Country> q = cb.createQuery(Country.class);
Root<Country> c = q.from(Country.class);
ParameterExpression<Integer> p =
cb.parameter(Integer.class);
q.select(c).where(cb.gt(c.get("population"), p));
Exemple
Avec JPQL
EntityManager em = ...;
String jpql = "select p from Person where p.age > 20";
Query query = em.createQuery(jpql);
List result = query.getResultList();
Exemple
Avec criteria
EntityManager em = ...
CriteriaBuilder qb = em.getCriteriaBuilder();
CriteriaQuery<Person> c =
qb.createQuery(Person.class);
Root<Person> p = c.from(Person.class);
Predicate condition = qb.gt(p.get(Person_.age), 20);
c.where(condition);
TypedQuery<Person> q = em.createQuery(c);
List<Person> result = q.getResultList();
Exemple

lors de leur anniversaire, nous voulons envoyer un bon


à tous les clients à long terme. Comment pouvons-nous
récupérer ceux qui correspondent?
Interface Specification
public interface Specification<T> {
Predicate toPredicate(Root<T> root, CriteriaQuery
query, CriteriaBuilder cb);
}
Interface Specification
Principe de l'utilisation des Specification
Créer un objet qui implémente l'interface Specification
Le DAO étend en plus , JpaSpecificationExecutor
Mettre le ou une combinaison de Specification en
paramètre des méthodes classiques de Spring Data

92 10/10/2021
Interface Specification
public CustomerSpecifications implements Specification<Customer>
{
public static Specification<Customer> customerHasBirthday() {
return new Specification<Customer> {
public Predicate toPredicate(Root<T> root, CriteriaQuery
query, CriteriaBuilder cb) {
return cb.equal(root.get(Customer_.birthday), today);
}
};
}
public static Specification<Customer> isLongTermCustomer() {
return new Specification<Customer> {
public Predicate toPredicate(Root<T> root, CriteriaQuery
query, CriteriaBuilder cb) {
return cb.lessThan(root.get(Customer_.createdAt), new
LocalDate.minusYears(2));
93
} 10/10/2021
};
Specification
Notre DAO étend en plus JpaSpecificationExecutor :
public interface CustomerRepository extends
JpaRepository<Customer>, JpaSpecificationExecutor {}

Le client peut ensuite les utiliser :


customerRepository.findAll(hasBirthday());
customerRepository.findAll(isLongTermCustomer());
customerRepository.findAll(where(customerHasBirthday()
).and(isLongTermCustomer()));

Ceci lit couramment, améliore la lisibilité et offre une flexibilité


supplémentaire par rapport à l'utilisation de l'API Critères JPA. La
seule mise en garde ici est que la Specificationmise en œuvre nécessite
94 un effort de codage assez important. 10/10/2021
QueryDsl
Principe de l'utilisation de QueryDsl
On inclut le plugin Maven de QueryDsl
Le DAO étend en plus QueryDslPredicateExecutor

95 10/10/2021
Exemple
Maven
Donc, pour que cela fonctionne, vous ajoutez Querydsl
à votre  pom.xml et configurez le plug-in APT en
conséquence.
Spring Data JPA
Exemple d'utilisation de QueryDsl
Notre DAO étend en plus JpaSpecificationExecutor :
public interface CustomerRepository extends JpaRepository<Customer>,
QueryDslPredicateExecutor {
}

Le client peut ensuite les utiliser :


BooleanExpression customerHasBirthday = customer.birthday.eq(today);

BooleanExpression isLongTermCustomer =
customer.createdAt.lt(today.minusYears(2));

customerRepository.findAll(customerHasBirthday.and(isLongTermCustomer));

98 10/10/2021
Spring Data JPA
Les transactions :
Toutes les méthodes pour récupérer des données sont en
readOnly=true. Les autres sont en @Transactional(donc
readOnly= false)
@Transactional est configurable (timeout, readOnly, …)
Pour qu’une suite d’opérations soient dans la même
transaction, il suffit de mettre @Transactional dans la
méthode englobante. Il faudra ajouter <tx:annotation-
driven /> dans la configuration

99 10/10/2021
BEN LAHMAR El Habib
SOA et web services

Attention à ne pas confondre les deux !


SOA est un ensemble de concepts :
Une SOA peut se mettre en œuvre sans Web Services

Les WS sont de l’ordre de la technologie :


On peut utiliser les Web Services sans faire de SOA
Les WS constituent la meilleure solution standardisée
disponible
Un service métier = un webservice
Cycle de vie d’un service

4 grandes phases :
 Identification
 Spécification
 Développement
 Gestion

1 aspect tranversal : la gouvernance


 Les architectures orientées service impliquent une vision
globale
 La gouvernance permet de casser les silos de l’entreprise
Cycle de vie des services (activités de gouvernance)
yes Service Owner
Service Search for Existing Approval
exists?
Identified Implementation
Service Candidate
no reusability Consumers
Service Identification Commission Identified

Service Specification Created


Service
Provider Interfaces Documented Specification
Review
Service/Process Workflow Created
Service Specification

Develop Integrate Create Acceptance Code in


Components & Test Deployment Unit Test repository
Service Development

Plan Depreca
Certify Service in Service Monitor Decommissi
New te
Service registry in use service on Service
Version Service

Service Management
Rôles associés au cycle de vie des services
i o n i on
t t
i ca Analyste métier i ca Architecte
ti f if
en éc
d
I • Définit les processus métiers et les Sp • Définit les services pour les use
KPI associées cases
• Identification des services métier • Modélise les services
• Optimise les processus via la
simulation

e nt e nt
m m
ppe Intégrateur p pe Développeur
l o lo
éve • Assemble les services é v•e Implémente les services
D D

t i on Gestionnaire
s
Ge
• Publie les services
• Gère le cycle de vie des services
• Contrôle la qualité de service
Zoom sur la phase d’identification

Un des problèmes centraux pour mettre en œuvre une SOA


 La granularité des services est fondamentale
 détermine en grande partie la réutilisabilité des services

Or succès SOA = % de réutilisation des services

 Éviter une granularité trop fine qui entraîne :


 beaucoup d’interactions
 des problèmes de performance

 On recommande des services à “gros grain”


 attention à une granularité trop “épaisse”
 un service qui fait trop de chose, risque de ne pas être réutilisable

Trouver le juste milieu…


méthodes d’identification des services

 Une première phase d'indentification doit être effectuée sur l'ensemble du


Système en s'appuyant sur la cartographie des domaines métiers de l'entreprise et
sur le code existant.
 Approche incrémentale : une phase d'identification est nécessaire au démarrage
de chaque nouveau projet SOA en s'appuyant sur les processus et services
répertoriés précédemment.

 Approche Bottom-up :
 On part des briques informatiques, on rassemble les bouts (abstraction)
 Plus adéquat pour réutiliser l’existant non “SOA-isé”

 Approche Top-down :
 On part des interactions métier pour aboutir aux interactions techniques
 Plus adéquat pour démarrer un nouveau projet
Approche “Bottom Up”
Besoins Legacy applications

Diagrammes Décomposition du
d'activités diagramme de classes

Orchestration Specification des services

Nouveaux Services + services


réutilisables (l'existant)

Nouvelle application
Approche “Top Down” 
Besoins Analyse des domaines métiers

Décomposition du processus métier

Orchestration Specification des services

Nouveaux Services + services


réutilisables (l'existant)

Nouvelle application
Approche “Outside in”
Dans la pratique on utilise rarement une seule approche

Pour obtenir une granularité pertinente des services, il est

nécessaire de concilier les 2


 Faire l’analyse Top-down sans se préoccuper de l’existant

 Faire l’analyse Buttom-up en ne considérant que l’existant

 Comparer les services “remontés” avec ceux déduits des processus

 Faire les compromis nécessaires pour réutiliser le maximum de code


WS: Définition

 A Web service is a software application identified by a URI,


whose interfacesand binding(1)are capable of being defined,
described and discoveredby XML artefacts and supports direct
interactions with other software applications using XML based
messagesvia Internet-based protocols. (W3C definition)(1)
 Un service Web est une application logicielle
1.identifiée par un URI dont les interfaces et les liaisons sont définies,
décrites et découvertes avec des mécanismes XML, et
2.supporte une interaction directe avec les autres applications
logicielles en utilisant des messages XML via un protocole Internet.
1- An association between an Interface, a concrete protocol anda
data format
WS: C’est quoi?
Les services Web sont
des service
Autonome
exposant des contrats
dont les frontières sont explicites
qui communiquent par messages
accessible sur le Web
Les messages sont véhiculés par des protocoles Web
WS: Pourquoi?
Les besoins des entreprises
 Flexibilité et indépendance
 La possibilité de réorganiser le système de façon rapide, efficace et
peu chère
 Partage d’informations/d’applications
 Entre partenaires, clients ou services
 Interopérabilité
 Tout le monde n’a pas la même organisation, les même systèmes
 Sécurité et confidentialité
 Comment partager des applications si tout le monde est protégé par
un pare-feu ?
 Garantie de livraison
WS: Pourqoui?
Les web services répondent à la question :
 Peut-on combiner les caractéristiques d’une architecture
distribuée à des protocoles de communication standards
et des clients légers ?
 Construits à partir des caractéristiques de la problématique
d’intégration d’applications et de partage d’informations
entre plate-formes hétérogènes ( et pas comment je fais
pour accéder à une méthode ?)
 Technologies acceptées par un grand nombre de
fournisseurs de logiciels et d’organismes ( Microsoft,
OMG, W3C, OASIS)
WS: intérêt
 XML est utilisé pour l’échange des données et messages.
 Ils permettent l’intégration de plate-formes hétérogènes via le protocole
HTTP
 Les développeurs ont l’embarras du choix en matière de langage de
programmation : Java, C, C++, Perl, Python, C#, et/ou Visual Basic,
 Peu ou pas de modification des applications existantes
 Permet une intégration faible, les composants sont simples mais
peuvent résoudre des problèmes complexes
 L’utilisation du protocole HTTP permet de passer les pare-feu
 Il n’existe pas de client propriétaire
 Outils de développement et de déploiement fournis par les principales
plate-formes J2EE et Microsoft .NET
 Permet la localisation et l’invocation dynamique d’autres services à
partir de registres privés ou publics
Rappel  Protocol
HTTP
Le Protocole
HTTP

 HyperText Transfer Protocol

 Protocole d’échanges d’information sur le web

 Basé sur TCP/IP

Requête HTTP

Réponse
HTTP HTTP
HTTP
Clients Server
Enchainement Client Serveur
UR
L Unique Resource


Location

 Identifie les ressources de manière unique sur

le Web

 4 parties
 Protocole (http, ftp, mail, …)
 Host (google.com)
 Port (8080, 80)
 Path (Chemin vers la ressource sur le serveur)
Requêtes HTTP
Permet à un client d’envoyer des messages à un
serveur
Format d’un message HTTP
Request Message Header
 Request Line
 Request Headers [Optional]
Request Message Body
Request Message Header

 Request POST /bibliotheque/faces/views/categorie/Create.xhtml HTTP/1.1


Line
 Request

Headers
Host:
localhost:8080
Connection:
keep-alive
Content-Length:
176
Cache-Control:
max-age=0
Accept:
text/html,applica
tion/xhtml+xml,
application/xml;
q=0.9,image/web
p,*/*;q=0.8
Origin:
http://localhost:8
080
Request Message Body

 Contient les données supplémentaires envoyées


au serveur
j_idt13:nom:Miage
j_idt13:description:NTDP
Réponse
HTTP

 Réponse du serveur au client

 Format d’une réponse HTTP


 Response Message Header
 Response Line
 Response Headers

 Response Message [Optional]


Response Message Header

Response
Line
HTTP/1.1 200 OK

Response
Headers
HTTP/1.1 200 OK
X-Powered-By: Servlet/3.1 JSP/2.3 (GlassFish Server Open Source Edition 4.0 Java/Oracle
Corporation/1.8) Server: GlassFish Server Open Source Edition 4.0
Content-Type:
text/html;charset=UTF-8 Date:
Sun, 23 Nov 2014 16:05:39 GMT
Content-Length: 2274
Response Message Body

Response
Body
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><html xmlns="http://www.w3.org/1999/xhtml
"><head><link
type="text/css" rel="stylesheet" href="/bibliotheque/faces/javax.faces.resource/theme.css?
ln=primefaces-aristo" /
><link type="text/css" rel="stylesheet"
href="/bibliotheque/faces/javax.faces.resource/css/jsfcrud.css" />
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>Create New Categorie</title></head><body>
<h1>Create New Categorie
</h1>
<p><div id="messagePanel"><table><tr style="color: green"><td>Categorie was successfully
created. </td>
</tr></table></div>
</html>
</html>
Méthodes
HTTP

 HTTP définit un ensemble de méthode permet


de caractériser les requêtes
 GET : Récupérer des ressources à un serveur
 POST : Envoyer des données à un serveur
 PUT : Modifier des données

 DELETE : Suppression de données

 OPTIONS : Demander la liste des méthodes


supportées par un serveur
 Autres : HEAD, TRACE, CONNECT
Services Web
RESTFul
Web Service REST
Définition

 Acronyme de REpresentational State
Transfert défini dans la thèse de Roy
Fielding en 2000.
  REST n’est pas un protocole ou un format,

contrairement à SOAP, HTTP ou RCP, mais un


style d’architecture inspiré de l’architecture du
web fortement basé sur le protocole HTTP

 Il n’est pas dépendant uniquement du web et

peut utiliser d’autre protocoles que HTTP


Web Service REST

Ce qu’il est :
 Un système d’architecture

 Une approche pour construire une

application

Ce qu’il n’est pas


 Un protocole

 Un format

 Un standard
REST 
 utilisation
  Utiliser dans le développement des
applications orientés ressources (ROA) ou
orientées données (DOA)

 Les applications respectant l’architecture

REST sont dites RESTful


REST 
 Fournisseurs
REST 
 Statistics
Statistique d’utilisation des services web REST et SOAP chez
AMAZON
REST 
 Caractéristiques

 Les services REST sont sans états (Stateless)


 Chaque requête envoyée au serveur doit contenir
toutes les informations relatives à son état et est traitée
indépendamment de toutes autres requêtes
 Minimisation des ressources systèmes (pas de gestion
de session, ni d’état)
 Interface uniforme basée sur les méthodes
HTTP (GET, POST, PUT, DELETE)
 Les architectures RESTful sont construites à partir
de ressources uniquement identifiées par des
URI(s)
Requêtes REST

 Ressources
 Identifiée par une URI ( http://
domain.dd/app/back/res)

 Méthodes (verbes) permettant de manipuler
les ressources (identifiants)
 Méthodes HTTP : GET, POST, PUT, DELETE

 Représentation : Vue sur l’état de la ressource
 Format d’échanges entre le client et le serveur
(XML, JSON, text/plain,…)
Ressources
 Une ressource est un objet identifiable sur
le système
  Livre, Catégorie, Client, Prêt

Une ressources n’est pas forcément un


objet matérialisé (Prêt, Consultation,
Facture…)
 Une ressource est identifiée par une URI : Une
http://benlahmar.net/bookstore/books/1
URI identifie uniquement une ressource surdeClef
le primaire
la ressource
dans la BDD
système
Méthodes (Verbes)
  Une ressource peut subir quatre opérations de
bases CRUD correspondant aux quatre
principaux types de requêtes HTTP (GET, PUT,
POST, DELETE)

 REST s’appuie sur le protocole HTTP pour

effectuer ces opérations sur les objets


 CREATE  POST
 RETRIEVE  GET
 UPDATE  PUT
 DELETE  DELETE
Méthode
GET

 La méthode GET renvoie une représentation de


la ressource tel qu’elle est sur le système
GET: http://benlahmar.net/bookstore/books/1

Statut : 200
Message :
Clien OK En-tête : Serveur
t ….
Représentatio
n : XML,
JSON, html,

Méthode
POST

 La méthode POST crée une nouvelle ressource sur


le système
POST: http://benlahmar.net/bookstore/books
Corps de la requête
Représentation : XML, JSON, html,…

Clien Statut : 201, 204 Serveur


t Message : Create, No content
En-tête : …..
Méthode DELETE

 Supprime la ressource identifiée par l’URI sur


le serveu Identifiant de la
ressource sur le
r DELETE: http://benlahmar.net
serveur

/bookstore/books/1

Clien Statut : 200 Serveur


t Message :
OK En-tête :
…..
Méthode
PUT

Mise à jour de la ressource sur le


système Identifiant de la
PUT: http://benlahmar.net/bookstore/books/1 ressource sur le
serveur

En-tête : …..
Corps de la requête : XML, JSON,

Clien Statut : 200 Serveur


t Message :
OK En-tête :
…..
Reflexions
 Que se passe t il
 sion fait de la lecture avec un POST ?
 Si on fait une mise à jour avec un DELETE ?

 Si on fait une suppression avec un PUT ?

 REST ne l’interdit pas


 Mais si vous le faites, votre application ne

respecte pas les exigences REST et donc n’est pas


RESTFul
Représentation
Une représentation désigne les données échangées entre le client et
le serveur pour une ressource:

 HTTP GET   Le serveur renvoie au client l’état de la
ressource

 PUT, POST   Le client envoie l’état d’une ressource au
serveur Peut être sous différent format :

 JSON

 XML

 XHTML

 CSV

 Text/plain

 …..
Rappel 
JSON
JSON
JSON « JavaScript Obect Notation » est un format
d’échange de données, facile à lire par un humain et
interpréter par une machine.
Basé sur JavaScript, il est complètement indépendant
des langages de programmation mais utilise des
conventions qui sont communes à toutes les langages
de programmation (C, C++, Perl, Python, Java, C#, VB,
JavaScript,….)
Deux structures :
 Une collection de clefs/valeurs  Object
 Une collection ordonnée d’objets  Array
JSON
Objet
Commence par un « { » et se termine par « } » et
composé d’une liste non ordonnée de paire clefs/
valeurs. Une clef est suivie de « : » et les paires
clef/ valeur sont séparés par « , »
{ "id": 51,
"nom": "Mathematiques 1", "resume":
"Resume of math ", "isbn": "123654",
"categorie":
{
"id": 2, "nom": "Mathematiques",
"description": "Description of
mathematiques "
},
"quantite": 42,
"photo": ""
}
JSON
ARRAY
Liste ordonnée d’objets commençant par « [« et se
terminant par « ] », les objets sont séparés l’un de
l’autre par « , ». [
{ "id": 51,
"nom": "Mathematiques 1",
"resume": "Resume of math ",
"isbn": "123654",
"quantite": 42,
"photo": ""
},
{ "id": 102,
"nom":
"Mathematiques
1",
"resume":
"Resume of math
", "isbn":
"12365444455",
"quantite": 42,
"photo": ""
}
]
JSON
Value
Un objet peut être soit un string entre « ""» ou un
nombre (entier, décimal) ou un boolean (true,
false) ou null ou un objet.
Partie 2

Développer des Web Services REST


JAX-RS

 Acronyme de Java API for RestFul Web
Services

 Version courante 2.0 décrite par JSR 339

 Depuis la version 1.1, il fait partie intégrante

de la spécification Java EE 6

 Décrit la mise en œuvre des services REST

web coté serveur



 Son architecture se repose sur l’utilisation

des classes et des annotations pour


développer les services web
JAX-RS : Développement
 Basé sur POJO (Plain Old Java Object) en
utilisant des annotations spécifiques JAX-RS
 Pas de modifications dans les fichiers
de configuration
 Le service est déployé dans une

application web
 Pas de possibilité de développer le service à partir
d’un WADL contrairement à SOAP
 Approche Bottom/Up
 Développer
et annoter les classes
 Le WADL est automatiquement généré par l’API
Annotation JAX-RS
La spécification JAX-RS dispose d’un ensemble
d’annotation permettant d’exposer une classe java
dans un services web :

 @Path

 @GET, @POST, @PUT, @DELETE

 @Produces, @Consumes

 @PathParam
Modéliser les URIs
URIs sont déterminés par l’annotation @Path

 Permet d’exposer une classe dans le WS

 Définit la racine des ressources (Root Racine

Ressources)

 Sa valeur correspond à l’URI relative de la

ressourc Adresse du serveur Ressource

e @Path("category")
public class CategoryService { http://localhost:8080/Bibliotheque/webresources/category
……
}
Contexte de
Port l’application
URIs des méthodes

 @Path peut être utilisée pour annoter des méthodes


d’une classe
 L’URI résultante est la concaténation entre le

valeur de @Path de la classe et celle de la


méthode
@Path("category")
public class CategoryFacade {
@GET
@Produces({MediaType.APPLICATION_XML,
MediaType.APPLICATION_JSON})
@Path("test")
public String hello()
{
return "Hello World!";
}
..
}

http://localhost:8080/Bibliotheque/webresources/category/test
URIs dynamiques

La valeur définie dans l’annotation @Path
n’est forcément un constante, elle peut être
variable.

 Possibilité de définir des expressions plus

complexes, appelées Template Parameters



 Les contenus complexes sont délimités par

« {} »

 Possibilité de mixer dans la valeur @Path des
@GET

expressions régulières
@Consumes ({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
@Produces ({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
@Path( "hello/{nom}")
public String hello (@PathParam("nom") String nom){
return "Hello " + nom;
}

http://localhost:8080/Bibliotheque/webresources/category/hello/Miage
URIs dynamiques
@GET
@Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
@Path("coucou/{nom}/{prenom}")
public String hello(@PathParam("nom") String nom,
@PathParam("prenom") String prenom) {
return "Hello " + nom + " " +
prenom;
}
GET http://localhost:8080/Bibliotheque/webresources/category/coucou/Miage/NTDP

@GET
@Cons
umes(
{Medi
aType
.APPL
ICATI
ON_JS
ON,
Media
Type.
APPLI GET http://localhost:8080/Bibliotheque/webresources/category/1
CATIO
N_XML
})
@Prod
uces(
{Medi
aType
@GET, @POST, @PUT,@DELETE

 Permettent de mapper une méthode à un type de
requête HTTP
 Ne sont utilisables que sur des méthodes

 Plusieurs méthodes peuvent avoir le même chemin,


le mapping uri/méthode est fait automatiquement par


JAX-RS en fonction du type de la requête
[GET/POST] http://localhost:8080/Bibliotheque/webresources/hello/habib/moi

@GET
@POST
@Produces({MediaType.APPLICATION_JSON, tring
MediaType.APPLICATION_XML}) @Produces({MediaType.APPLICATION_JSON,
@Path("hello/{nom}/{prenom}") MediaType.APPLICATION_XML})
@Path("hello/{nom}/{prenom}")
public String hello(@PathParam("nom") S
public String
nom, @PathParam("prenom") String prenom) {
helloPost(@PathParam("nom")
return "GET " + nom + " " + prenom;
} String nom, @PathParam("prenom") String prenom) {
} return "POST " + nom + " " + prenom;
@GET, @POST, @PUT,@DELETE

 Les opérations CRUD sur les ressources sont


réalisées au travers des méthodes de la requête
HTTP

/books
GET : Liste des livres
POST : Créer un
nouveau livre
GET, POST
PUT, /books/{id}
GET : Livre identifié par l’id
DELETE PUT: Mis à jour du livre identifié par id
DELETE : Supprimer le livre identifié par
id
les annotations indispensables
@RequestMapping
Cette annotation est utilisée au niveau de la classe et de la méthode.
L'annotation @RequestMapping est utilisée pour mapper des requêtes
Web sur des classes et des méthodes de gestionnaires spécifiques.
Lorsque @RequestMapping est utilisé au niveau de la classe, elle crée
un URI de base pour lequel le contrôleur sera utilisé. 

@CookieValue
Cette annotation est utilisée au niveau du paramètre de méthode.
@CookieValue est utilisé comme argument d'une méthode de
mapping de requête. Le cookie HTTP est lié au paramètre
@CookieValue pour un nom de cookie donné. Cette annotation est
utilisée dans la méthode annotée avec @RequestMapping.
les annotations indispensables
@CrossOrigin
Cette annotation est utilisée à la fois au niveau de la
classe et de la méthode pour permettre les demandes
d'origine croisée.
@EnableAsync cette annotation active la capacité de
Spring à exécuter des méthodes @Async dans un pool
de threads en arrière-plan.
les annotations indispensables
Composées variantes de @RequestMapping 
Spring framework 4.3 a introduit les variantes au niveau
méthode de l'annotation @RequestMapping pour mieux
exprimer la sémantique des méthodes annotées.
L'utilisation de ces annotations est devenue la norme de
définition des points de terminaison. Ils agissent comme des
wrappers à @RequestMapping.
@GetMapping
@PostMapping
@PutMapping
@PatchMapping
@DeleteMapping
@GetMapping = @RequestMapping + Http GET method ;
@PostMapping = @RequestMapping + Http POST method ;
@PutMapping = @RequestMapping + Http PUT method ;
@DeleteMapping = @RequestMapping + Http DELETE method.
les annotations indispensables
@ExceptionHandler
Cette annotation est utilisée aux niveaux de la méthode pour
gérer les exceptions au niveau du contrôleur. 
@InitBinder
Cette annotation est une annotation au niveau de la méthode
qui joue le rôle d'identifier les méthodes qui initialisent
theWebDataBinder - un DataBinder permet de lier le paramètre
de requête aux objets JavaBean. Pour personnaliser la liaison
des données de paramètre de requête, vous pouvez utiliser des
méthodes annotées @InitBinder dans notre contrôleur. Les
méthodes annotées avec @InitBinder incluent tous les types
d'arguments supportés par les méthodes de gestionnaire.
les annotations indispensables
@Mappings et @Mapping
Cette annotation est utilisée dans les champs.
L'annotation @Mapping est une méta-annotation qui
indique une annotation de mappage Web. Lors du
mappage de différents noms de champs, vous devez
configurer le champ source sur son champ cible, et
pour ce faire, vous devez ajouter l'annotation
@Mappings. Cette annotation accepte un tableau de
@Mapping ayant les champs source et cible.
@PathVariable
Cette annotation est utilisée pour annoter les
arguments de la méthode du gestionnaire de requêtes. 
@RequestAttribute
Cette annotation est utilisée pour lier l'attribut de
requête à un paramètre de méthode de gestionnaire. 
@RequestParam
Cette annotation est utilisée pour annoter les
arguments de la méthode du gestionnaire de requêtes.
@RequestBody
Cette annotation est utilisée pour annoter les
arguments de la méthode du gestionnaire de requêtes.
L'annotation @RequestBody indique qu'un paramètre
de méthode doit être lié à la valeur du corps de la
requête HTTP.
Le HttpMessageConveter est responsable de la
conversion du message de requête HTTP en objet.
les annotations indispensables
@RequestPart
Cette annotation est utilisée pour annoter les
arguments de la méthode du gestionnaire de requêtes.
L'annotation @RequestPart peut être utilisée à la place
de @RequestParam pour obtenir le contenu d'une
multipart spécifique et la lier à l'argument de méthode
annoté avec @RequestPart.
les annotations indispensables
@ResponseBody
@ResponseStatus
@ControllerAdvice
@RestController
@SessionAttribute
@SessionAttributes
Exemple
Entity
Couche DAO
LA COUCHE SERVICE
LE CONTRÔLEUR
FILTRE CORS
@CrossOrigin

@CrossOrigin(origins = "http://localhost:9000")
@GetMapping("/greeting")
public Greeting greeting(@RequestParam(required=false, defaultValue="World") String
name)
{
System.out.println("========");
return new Greeting(counter.incrementAndGet(),
String.format(template, name));
}
Atelier : implémentation et consommation d'un
web service REST avec accès au base de données

Voir atelier
Architecture Rappel
Les couches
Consommation d’un WS Rest
Qu'est-ce que RestTemplate?
RestTemplate est la classe centrale de Spring pour les
accès HTTP synchrones côté client. Il vise à simplifier
la communication avec les serveurs HTTP et à
appliquer les principes RESTful.
Utiliser RestTemplate
Get Plain JSON
Récupération de POJO au lieu de JSON
Utilisez HEAD pour récupérer les en-têtes
Utilisez POST pour créer une ressource
L' API postForObject

L' API postForLocation
faire un POST avec l' API d' échange plus
générique
L' API d' échange
Utilisez OPTIONS pour obtenir des
opérations autorisées
Simple PUT avec .exchange
DELETE pour supprimer une ressource
Configurer le délai d'attente
Rest repository
Pom
<dependencies>
...
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>
...
</dependencies>
Changer l’URI de base
spring.data.rest.basePath=/api
PERSON Personnaliser ALISER

@RestResource(path = "byName", rel = "customFindMethod")


Personnaliser
Top 10
Les 10 risques les plus
critiques des applications
Web
On parle de risques, et non plus uniquement de vulnérabilités.

La méthodologie de calcul du risque de l’OWASP Top 10 Basée sur la méthodologie


OWASP Risk Rating Methodology
What is a vulnerability ?

192
OWASP Top 10 – 2007 (Previous) OWASP Top 10 – 2010 (New)
Mapping Top10 2007 - Top 10 20
A2 – Injection Flaws A1 – Injection

A1 – Cross Site Scripting (XSS) A2 – Cross Site Scripting (XSS)

A7 – Broken Authentication and Session A3 – Broken Authentication and Session


Management Management

A4 – Insecure Direct Object Reference A4 – Insecure Direct Object References


=
A5 – Cross Site Request Forgery (CSRF) A5 – Cross Site Request Forgery (CSRF)
=
<was T10 2004 A10 – Insecure Configuration
A6 – Security Misconfiguration (NEW)
Management> +
A10 – Failure to Restrict URL Access A7 – Failure to Restrict URL Access

<not in T10 2007> + A8 – Unvalidated Redirects and Forwards (NEW)


A8 – Insecure Cryptographic Storage A9 – Insecure Cryptographic Storage

A9 – Insecure Communications A10 – Insufficient Transport Layer Protection

A3 – Malicious File Execution


- <dropped from T10 2010>
A6 – Information Leakage and Improper Error - <dropped from T10 2010>
Handling
Mapping Top10 2010 - Top 10 2013

196
198
L’OWASP Top10
A2: Violation de (2013 rc1) A4: Mauvaise
Gestion A3: Cross Site gestion des
A1: Injection
d'Authentification Scripting (XSS) sessions et de
et de Session l’authentification

A5:Référence A7: Manque de


A8: Cross Site
directe non A6: Exposition de contrôle d’accès
Request Forgery
sécurisée à un données sensibles au niveau
(CSRF)
objet fonctionnel

A9: Utilisation de
A7: Redirections
composants avec
et renvois non
des vulnérabilités
validés
connues
http://www.owasp.org/index.php/Top_10
A1 – Injection
 L'attaque par injection est évaluée par l'OWASP
comme étant la plus risquée, car la faille est assez
répandue, il est facile de l'exploiter et l'impact peut être
très important.
 Cela va de la simple récupération de données à la
prise totale de contrôle du serveur.
 La victime de l'attaque est un des composants
techniques de l'application Web.

200
A1 – Injection

201
A1 – Les types d’injections
 SQL Injection (WASC-19)
 XML Injection (WASC-23)
 Null Byte Injection (WASC-28)
 LDAP Injection (WASC-29)
 Mail Command Injection (WASC-30)
 OS Commanding (WASC-31)
 XPath Injection (WASC-39)
 XQuery Injection (WASC-46)

202
Exemple sur l’injection SQL
"SELECT * FROM
Account Summary
Account:
accounts WHERE

Knowledge Mgmt
Communication

Legacy Systems
Administration

Bus. Functions
Application Layer

Human Resrcs
E-Commerce
Transactions
SKU:

Web Services
acct=‘’ OR

Directories
Accounts

Databases
Acct:5424-6066-2134-4334

Finance
HTTP

Billing
HTTP SQL DB Table Acct:4128-7574-3921-0192
response 
1=1--’"
request query Acct:5424-9383-2039-4029
APPLICATION 
  Acct:4128-0004-1234-0293

ATTACK

Custom Code
1. L’application fourni un
formulaire
2. L’attaquant envoi son attaque
dans les données du formulaire
App Server
3.L’application transfère les
Web Server
données à la requête SQL
Hardened OS
4. Le SGBD lance la requête
Network Layer

contenant l’attaqueet renvoie le


résultats à l’application.
Firewall
Firewall

5. L’application renvoie ce résultat


à l’utilisateur
A1 – Comment se protéger
Recommandations
1. Penser comme attaquants U/AX ( l’Expérience
Utilisateur/Attaquant )
2. Ne faites pas confiance au utilisateur/non-
utilisateurs inputs
3. Ne pas stocker les mots de passe comme Plaintext
dans la base de données (Salt & Hash all)
4. Ne pas Affecter droit d'accès de type admin ou
DBA à vos comptes d'application
5. Ne pas Exécuter le SGBD en tant que root ou
system
A1 – Comment se protéger
1. Se passer des interpréteurs,
2. Utiliser une interface permettant de préparer les
requêtes (ex, prepared statements, or les procédures
stockées),
3. Encoder toutes les données fournies par l’utilisateur
avant de les passer à l’interpréteur
 Toujours effectuer une validation de type “white liste”
sur les données utilisateurs.
 Minimiser les privilèges dans les bases pour limiter
l’impact de la faille.
205
References
A1 – Injection XML
 XPath Injection (WASC-39)
 XQuery Injection (WASC-46)
 XML Injection (WASC-23)

206
Xpath Injection
Xpath est utilisé pour parcourir de manière rapide et
puissantes les documents XML complexes. (voir aussi
Xquery)

207
A1- Injection Xpath
<?xml version= "1.0" encoding= "ISO-8859-1"?>
<users>
<user> <id>1</id> <identifiant>admin</identifiant>
<password>test1234</password>
</user> ' or 1=1 or 'a'='a
<user> <id>2</id> <identifiant>usertest</identifiant>
<password>testuser</password>
Voir exemple
</user>
</users>

208
A2 – Violation de Gestion d’authentification et de Session
Les fonctions applicatives relatives à l'authentification et la gestion de session ne sont souvent
pas mises en œuvre correctement, permettant aux attaquants de compromettre les mots de
passe, clés, jetons de session, ou d'exploiter d'autres failles d'implémentation pour s'approprier
les identités d'autres utilisateurs

212
A2 – Cross-Site Scripting (XSS)
Cross-Site Scripting Illustré
L’attaquant découvre le script vulnérable
1

Application disposant
de faille XSS
L’attaquant entre un script
malicieux sur la page
web(stocké) ou bien utilise un
lien(réfléchi) permettant

Knowledge Mgmt
d’envoyer vers la page

Communication
Administration

Bus. Functions
E-Commerce
Transactions
La victime se rend sur la page

Accounts
2

Finance
Custom Code

Le Script s’execute sur le


navigateur de la victime
sans qu’il ne le sache

3 L’attaquant recoit le cookie ou autre élément directement


A4- Références directes non sécurisées à un
objet

215
A4- Références directes non sécurisées à un objet

 L’attaquant note le
https://www.onlinebank.com/user?acct=6065 paramètre acct = 6065
?acct=6065

 Il modifie celui-ci de la
manière suivante
?acct=6066

 L’attaquant visualise un
autre compte.
A5- Mauvaise configuration Sécurité

217
A5- Mauvaise configuration Sécurité

Knowledge Mgmt
Communication
Administration

Bus. Functions
E-Commerce
Transactions
Accounts
Finance
Database

Custom Code

App Configuration

Development
Framework

App Server
QA Servers
Web Server

Hardened OS
Insider Test Servers

Source Control
A6 - Exposition de données sensibles

219
Différents niveaux dans la protection des
données

220
Stockage non sécurisé
La victime stocke son
numéro de carte de
crédit dans le système
1 via un formulaire

Communication
Administration

Bus. Functions
E-Commerce
Transactions

Knowledge
Accounts
Finance

Mgmt
Custom Code

Fichier de log
4 Une personne
malveillante interne Le gestionnaire des 2
vole 4 millions de erreurs loggue le numéro
carte de crédit de carte car la passerelle
de commerce est
Les logs sont rendus 3 indisponible.
disponibles pour tous les
membres internes dans le
but du debug
A7 Manque de contrôle d’accès au niveau
fonctionnel

222
A8 Falsification de requête intersite (CSRF)

223
CSRF : Exemple de scénario d’attaque

L’attaquant pose son piège sur un site internet (ou via un e-mail)
1

Application vulnérable
Un tag chaché <img> au CSRF
contient une attaque
vers un site vulnérable

Knowledge Mgmt
Communication
Administration

Bus. Functions
E-Commerce
Transactions
Accounts
Finance
Tout en étant logguer sur le site vulnérable, la victime
2 parcourt le site de l’attaquant.
Custom Code

3
Le site vulnérable ne
Le tag <img> tag chargé voie que des requêtes
par le navigateur envoie légitimes et effectue
une requête GET l’action demandée
(contenant des identifiants
sur le site vulnérable)
Exemples
Scénario avec GET:
 GET http://bank.com/transfer.do?acct=BOB&amount=100 HTTP/1.1

 <a href="http://bank.com/transfer.do?acct=MARIA&amount=100000">View my
Pictures!</a>

 <img src="http://bank.com/transfer.do?acct=MARIA&amount=100000" width="0"


height="0" border="0">

Scénario avec POST:


 POST http://bank.com/transfer.do HTTP/1.1 acct=BOB&amount=100

225
Exemples

226
A9 Utilisation de composants avec des
vulnérabilités connues

227
Suis-je vulnérable?

228
Exemple d’attaque

229
Exemple d’attaque

230
A10- Redirections et Renvois Non Validés

231
Redirection illustrée
1 L’attaquant envoi à la victime via un email ou une page
Web de son choix le lien.
From: Internal Revenue Service
Subject: YourUnclaimedTaxRefund
L’application redirige la
Our records show you have an 3 victime vers le site de
unclaimedfederaltaxrefund. Please
l’attaquant
click here to initiateyour claim.

Knowledge Mgmt
Communication
Administration

Bus. Functions
E-Commerce
Transactions
Accounts
La vicitime clique sur le lien contenant une donnée

Finance
2 non validée.

Custom Code

Request sent to vulnerable


site, including attacker’s
destination site as parameter.
Redirect sends victim to
attacker site Evil Site

Le site malveillant installe des


http://www.irs.gov/taxrefund/claim.jsp?year=2006 4 éléments sur le navigateur ou
&… &dest=www.evilsite.com récupére des données
Unvalidated Forward Illustrated
L’attaquant envoie sa charge sur une page vulnérable ou il a
1 accès

Request sent to
vulnerable page which
user does have access to.
public void
Redirect sends user sensitiveMethod( HttpServletRequest
request, HttpServletResponse
directly to private page, response) {
try {
bypassing access control. // Do sensitive
stuff here.
...
}
catch ( ...
L’application autorise la
2 requête et continue vers Filtre
la page vulnérable La page de transfert ne contrôle pas le
3 paramètre et renvoie l’attaquant vers
la page non autorisée, passant outre le
public void doPost( HttpServletRequest request, contrôle d’accès.
HttpServletResponse response) {
try {
String target = request.getParameter( "dest" )
);
...
request.getRequestDispatcher( target ).forward(req
uest, response);
}
catch ( ...
Synthèse….

234
Spring Secrity
Introduction à Spring Security
Spring Security permet de sécuriser des applications
Spring, en particulier dans un environnement Java EE
 Il fonctionne dans tous les serveurs d’applications
 Il vient alors remplacer la sécurité standard Java EE
 Il est très répandu en production, car il propose des
fonctionnalités particulièrement avancées
 Il se configure via un fichier de configuration Spring
 Il peut sécuriser des URLs mais aussi des méthodes
Java
Authentification et Autorisation
JAAS
Il y a deux concepts principaux en sécurité
 Authentification
Vérification de l’identité de la personne
 En entreprise, on utilise généralement un serveur LDAP
 Autorisations
 Les droits sur l’application possédés par la personne
 Généralement, ces droits sont stockés dans un serveur
LDAP ou une base de données
 Spring Security permet de traiter ces deux concepts de
manière indépendante : par exemple l’authentification en
LDAP et les autorisations en base de données
Fonctionnement interne
 Spring Security va en fait déléguer la gestion des
URLs demandées à une chaîne de filtres spécialisés
 Ils vont valider si un utilisateur est authentifié ou non
 Ils vont valider si un utilisateur a le droit d’accéder à
la ressource ou non
 Ils vont gérer l’authentification et la déconnexion de
l’utilisateur
 Ils vont gérer les cas d’erreurs et rediriger l’utilisateur
vers les pages d’erreurs
Dépendance

Spring Boot nous fournit donc un mot de passe par défaut


Accès
Désactivé Auto-Configuration
Methode 1

@SpringBootApplication(exclude =
{ SecurityAutoConfiguration.class })
public class SpringBootSecurityApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(SpringBootSecurityApplication.class,
args);
    }
}
Désactivé Auto-Configuration
Méthode 2:
Dans le fichier application.properties ajouter cette
configuration:

spring.autoconfigure.exclude=org.springframework.
boot.autoconfigure.security.SecurityAutoConfiguratio
n
Désactivation ou dépassement de la
configuration automatique de la sécurité
 Il existe une différence significative entre la désactivation de la configuration
automatique et son dépassement.
 En le désactivant, cela revient à ajouter la dépendance à partir de Spring
Security et l’ensemble de la configuration. Cela peut être utile dans plusieurs
cas:
 Intégration de la sécurité des applications à un fournisseur de sécurité personnalisé
 Migration d'une application Spring héritée avec une configuration de sécurité
existante - vers Spring Boot

Cependant, la plupart du temps, nous n’aurons pas besoin de désactiver


complètement la configuration automatique de la sécurité.
 La façon dont Spring Boot est configuré permet de dépasser la sécurité
configurée automatiquement en ajoutant nos nouvelles classes de
configuration / personnalisées. Cela est généralement plus facile, car nous ne
faisons que personnaliser une configuration de sécurité existante pour
répondre à nos besoins.
Exemple de personnalisation

Configuring Spring Boot Security


User, Password and Role
On peut définir notre propre username & password

spring.security.user.name=moi
spring.security.user.password=moi

spring.security.user.role= # A comma
separated list of roles
Authentification
La première étape est de créer un bean de
configuration

Lors du chargement de ce bean, un filtre de servlet


(springSecurityFilterChain) est créé. C’est ce dernier qui
orchestrera toute la sécurité (protection des URL, la validation
login, mot de passe, ...) au sein de votre application. 
Password encoder
Authentification
L'annotation @EnableWebSecurity est cruciale si
nous désactivons la configuration de sécurité par
défaut.

Si elle est manquante, l'application ne pourra pas


démarrer. L'annotation est uniquement facultative si
nous ne faisons que redéfinir le comportement par
défaut à l'aide d'un WebSecurityConfigurerAdapter.
Auth

Par défaut plusieurs fonctionnalités sont activées


• sécurisation de toutes le URL de l’application
•génération d’un formulaire par défaut pour s’authentifier
•service pour se loguer et se déloguer
•différentes fonctionnalités pour prévenir les attaques cross domain, la
fixation de session
...
Avec DB
Une entité
Un repository avec la méthode findBy…
User findByUsername(String username);

Implémentation de l’interface UserDetailsService


Implémentation de l’interface UserDetails (dans user
ou autre)
Autorisations
Autorisations
Vous pouvez être moins restrictif ou plus restrictif sur la
définition des autorisations liées aux requêtes. Par exemple :
Autorisations
vous pouvez également restreindre les droits sur vos
méthodes.

Pour activer la sécurité via les annotations vous devrez ajouter


l’annotation @EnableGlobalMethodSecurity dans votre classe de
configuration. 
Exemple
Password
Spring Security nous fournit des fonctionnalités prêtes
à l'emploi pour l'encodage des mots de passe. 
Le codeur de mot de passe est une interface utilisée
lors du processus d'autorisation.
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.password.PasswordEncoder;
 
@Configuration
public class PasswordEncoderConfig {
 
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new PasswordEncoder() {
            @Override
            public String encode(CharSequence rawPassword) {
                return rawPassword.toString();
            }
 
            @Override
            public boolean matches(CharSequence rawPassword, String encodedPassword) {
                return rawPassword.toString().equals(encodedPassword);
            }
        };
ajouter un encodeur de mot de passe
personnalisé. 
@Bean
public PasswordEncoder customPasswordEncoder() {
 
    return new PasswordEncoder() {
 
        @Override
        public String encode(CharSequence rawPassword) {
 
            return BCrypt.hashpw(rawPassword.toString(), BCrypt.gensalt(4));
        }
 
        @Override
        public boolean matches(CharSequence rawPassword, String encodedPassword) {
 
            return BCrypt.checkpw(rawPassword.toString(), encodedPassword);
        }
    };
}
Implem
App
Générer un pass
System.out.println(BCrypt.hashpw("user-
password",BCrypt.gensalt(4)));
$2a$04$i4UWtMw6surai4dQMhoKSeLddi1XlAh2sSyG58K3Zv
BHqVkhz8Y3y

définir nos variables d’environnement avant d’exécuter notre


application Spring Boot.
SPRING_SECURITY_USER_NAME=test-user
SPRING_SECURITY_USER_PASSWORD=$2a$04$i4UWtMw
6surai4dQMhoKSeLddi1XlAh2sSyG58K3ZvBHqVkhz8Y3y
Personnalisation
 Création user Entity

 IMPLÉMENTATION DE LA CLASSE
APPAUTHENTICATIONPROVIDER
L’implémentation standard et la plus courante est
le DaoAuthenticationProvider – qui récupère les détails
de l’utilisateur à partir d’un simple DAO utilisateur en
lecture seule
 IMPLÉMENTATION DU REPOSITORY USERREPOSITORY
IMPLÉMENTATION DU SERVICE
USERSERVICE
IMPLÉMENTATION DE LA CLASSE DE
CONFIGURATION SECURITYCONFIG
IMPLÉMENTATION DE LA CLASSE DE
CONFIGURATION SECURITYCONFIG
IMPLÉMENTATION DE LA CLASSE DE
CONFIGURATION SECURITYCONFIG
IMPLÉMENTATION DE LA CLASSE DE
CONFIGURATION SECURITYCONFIG
Authentification basée sur
les Sessions :

Problème de montée en
charge
Sécurité basée sur les sessions :
Problème de montée en charge
SessionID=11
SessionID=1
Server
1
Instanc
CLT e 1
HTTP Req
Req1
1 Server
SessionID Http SessionID=1
=12 Req Instanc
CLT
Serve e 2 4
Req 4
HTTP r
2
Load
SessionID=13 Req Balance Req2
3 r Server
CLT
HTTP
Req Req Instanc SessionID=1
4 3 e 3 2
SessionID=1
4 Server
Instanc
CLT e 4 SessionID=1
HTTP
3
Sécurité basée sur les sessions :
Problème de montée en charge
SessionID=11
SessionID=1
Server
1
Instanc
CLT e 1
HTTP Req
Req1
1 Server
SessionID Http SessionID=1
=12 Instanc
CLT
Serve e 2 4
HTTP r
Load
SessionID=13 Balance
r Server
CLT
Instanc SessionID=1
HTTP
e 3 2
SessionID=1
4 Server
Instanc
CLT e 4 SessionID=1
HTTP
3
SessionID=11
SessionID=1
Server
1
Instanc
CLT e 1
HTTP
Req1 ? SessionID=11
Server
SessionID Http SessionID=14
=12 Instanc
CLT
Serve Req e 2
HTTP r 1
Load
SessionID=13 Balance
r Server
CLT
Instanc SessionID=1
HTTP
e 3 2
SessionID=1
4 Server
Instanc
CLT e 4 SessionID=1
HTTP
3
Cache Partagé pour les sessions

SessionID=1
Server
1
Instanc
CLT e 1
HTTP Req
Req1
1 Server
SessionID Http
=12 Req Instanc
CLT
Serve e 2 Cache
Req 4
HTTP r Mémoir
2
Load e
SessionID=13 Req Balance Req2 Partagé
3 r Server Sessions
CL
HTTP
T
Req Req Instanc 11, 12,13,
4 3 e 3 14
SessionID=1
4 Server
Instanc
CLT e 4
HTTP
Cache Partagé pour les sessions

SessionID=1
Server
1
Instanc
CLT e 1
HTTP Req
Req1
1 Server
SessionID Http
=12 Req Instanc
CLT
Serve e 2
Req 4
HTTP r Cache
2
Load MéSimngoleire
SessionID=13 Req Balance Req2 PPoairnttaOgéf
3 r Server SeFsasiliuornes
CLT 11, 12,13, 14
HTTP
Req Req Instanc
4 3 e 3
SessionID=1
4 Server
Instanc
CLT e 4
HTTP
Cache Distribué pour les sessions
Cache
D istribu
SessionID=1 Sessions :
Server é
1 11, 12,
Instanc 13, 14
CLT e 1
HTTP Req
Req1
1 Server Sessions :
SessionID Http 11, 12,
=12 Req Instanc
CLT
Serve e 2
13, 14
Req 4
HTTP r
2
Load
SessionID=13 Req Balance Req2
3 r Server Sessions :
CLT
HTTP
Req Req Instanc 11, 12,
13, 14
4 3 e 3
SessionID=1
4 Server
Sessions :
Instanc 11, 12,
CLT e 4 13, 14
HTTP
Cache Distribué pour les sessions :
Tolérance aux panes
Cache
D istribu
SessionID=1 Sessions :
Server é
1 11, 12,
Instanc 13, 14
CLT e 1
HTTP Req
Req1
1 Server Sessions :
SessionID Http 11, 12,
=12 Req Instanc
CLT
Serve e 2
13, 14
Req 4
HTTP r
2
Load
SessionID=13 Req Balance Req2
3 r Server Sessions :
CLT
HTTP
Req Req Instanc 11, 12,
13, 14
4 3 e 3
SessionID=1
4 Server
Sessions :
Instanc 11, 12,
CLT e 4 13, 14
HTTP
Sticky Sessions
Cache
D istribu
SessionID=1 Sessions
Server é
1 :11,
Instanc
CLT e 1
HTTP Req
Req1
1 Server
SessionID Http Sessions :
=12 Instanc 14,
CLT
Serve e 2
HTTP r
Load
SessionID=13 Balance
r Server
CLT Sessions :
Sticky Instanc
HTTP 12,
e 3
Session
SessionID=1
4 s Server
Instanc Sessions :
CLT e 4 13,
HTTP
Sticky Sessions
Cache
D istribu
SessionID=1 Sessions
Server é
1 :11,
Instanc
CLT e 1
HTTP
Server
SessionID Http Sessions :
=12 Instanc 14,
CLT
Serve e 2
Req
HTTP r
2
Load
SessionID=13 Balance Req2
r Server
CLT Sessions :
Sticky Instanc
HTTP 12,
e 3
Session
SessionID=1
4 s Server
Instanc Sessions :
CLT e 4 13,
HTTP
Sticky Sessions
Cache
D istribu
SessionID=1 Sessions
Server é
1 :11,
Instanc
CLT e 1
HTTP
Server
SessionID Http Sessions :
=12 Instanc 14,
CLT
Serve e 2
HTTP r
Load
SessionID=13 Req Balance
3 r Server
CLT Sessions :
Sticky Req Instanc
HTTP 12,
3 e 3
Session
SessionID=1
4 s Server
Instanc Sessions :
CLT e 4 13,
HTTP
Sticky Sessions
Cache
D istribu
SessionID=1 Sessions
Server é
1 :11,
Instanc
CLT e 1
HTTP
Server
SessionID Http Sessions :
=12 Req Instanc 14,
CLT
Serve e 2
r 4
HTTP
Load
SessionID=13 Balance
r Server
CLT Sessions :
HTTP
Req Sticky Instanc
12,
4 e 3
Session
SessionID=1
4 s Server
Instanc Sessions :
CLT e 4 13,
HTTP
Sticky Sessions :
Problème de tolérance aux pannes
Cache
D istribu
SessionID=1 Sessions
Server é
1 :11,
Instanc
CLT e 1
HTTP
Server
SessionID Http Sessions :
=12 Req Instanc 14,
CLT
Serve e 2
r 4
HTTP
Load
SessionID=13 Balance
r Server
CLT Sessions :
HTTP
Req Sticky Instanc
12,
4 e 3
Session
SessionID=1
4 s Server
Instanc Sessions :
CLT e 4 13,
HTTP
Cache Distribué
et Sticky Sessions
Cache
D istribu
SessionID=1 Sessions :
Server é
1 11, 12,
Instanc 13, 14
CLT e 1
HTTP Req
Req1
1 Server Sessions :
SessionID Http 11, 12,
=12 Req Instanc
CLT
Serve e 2
13, 14
Req 4
HTTP r
2
Load
SessionID=13 Req Balance Req2
3 r Server Sessions :
CLT
HTTP
Req Sticky Req Instanc 11, 12,
13, 14
4 3 e 3
Session
SessionID
=14 s Server
Sessions :
Instanc 11, 12,
CLT e 4 13, 14
HTTP
Est-ce qu’il n’y a pas plus simple
L’idée étant de :
◦ Gérer la session coté client ?
◦ Chercher un moyen qui permet au
serveur de faire confiance aux
clients Web
◦ Sans avoir besoin de stocker sa
session coté serveur
T
Client Serveur
BD
HTTP Applicatio
n
Connexion
Socke Socke
POST /Login?username
t username=x&pass=y t
SQL

200 O K Générer le Token


Index.html
JWT en calculant
JWT Header = Une signature
H.P..S Basée sur un
Déconnexi secret
Nouvelle
on Connexion
Socke Socke
t Requête HTTP 2 : t
Vérifier la signature
POST/SaveJWT Header ;
H.P.S
Du JWT en
Réponse HTTP 2 utilisant Le secret
Vue confirmation de
Déconnexion
l’enregistrement
Json Web Token
 JSON Web Token (JWT) est un standard
(RFC 7519) qui définit une solution
compacte et autonome pour
transmettre de manière sécurisée des
informations entre les applications en
tant qu'objet structuré au format JSON
(Java Script Object Notation).
 Cette information peut être vérifiée et
fiable car elle est signée
numériquement.
 Compact:
◦ en raison de leur petite taille, les JWT peuvent
être envoyés via une URL, un paramètre
POST ou dans un en-tête HTTP. De plus, la
plus petite taille signifie que la transmission
est rapide.
 Autonome:
◦ Le JWT contient toutes les informations
requises sur l'utilisateur, ce qui évite d'avoir à
interroger la base de données plus d'une fois
pour connaitre le détail de l’identité d’un client
authentifié.
Structure de JWT
 JWT est constitué de trois
parties séparées par un point « .
»:
◦ Header
◦ Payload
◦ Signature
 La forme d’un JWT est donc :
◦ xxx.yyy.zzz
JWT : Header
 L'en-tête se compose généralement de deux
parties:
◦ Le type du jeton, qui est JWT,
◦ L'algorithme de hachage utilisé, tel que :
 H M A C (Hash Message Authentication Code) : Symétrique (Clé
privé)
 R S A (Ronald Rivest (2015),Adi Shamir (2013) et Leonard
Adleman (2010).) :Asymétrique avec clés Publique et Clé Privée
 La structure du Header est un objet JSON ayant la
forme la suivante :
 {
 "alg": "HS256",
 "typ": "JWT"
 }
  Cet objet JSON est ensuite encodé
en Base64URL. Ce qui donne la forme suivante :
 eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
JWT : Payload
 La deuxième partie du jeton est le Payload, qui
contient les claims (revendications.)
 Les claims sont des déclarations concernant :
◦ Une entité (généralement l'utilisateur)
◦ Des métadonnées supplémentaires.
 Il existe trois types de claims :
◦ Enregistrées (Registred)
◦ publiques (Public)
◦ Privées (Private)
JWT : Payload
 Registred Claims :
◦ Il s'agit d'un ensemble de revendications prédéfinies
qui ne sont pas obligatoires mais recommandées
pour fournir un ensemble de revendications utiles et
interopérables. Certains d'entre eux sont:
 iss (issuer : Origine du token),
 exp (heure d'expiration),
 sub (sujet),
 aud (public cible),
 nbf (Not Before :A ne pas utiliser avant cette date)
 iat ( issued at : date de création du token).
 jti ( JWT ID identifiant unique du JWT).
JWT : Payload
 Public Claims :
◦ Celles-ci peuvent être définies à volonté par ceux
qui utilisent des JWT.
◦ Mais pour éviter les collisions, elles doivent être
définies dans le registre des jetons Web IANA JSON
( IANA JSON Web Token Registry :
https://www.iana.org/assignments/jwt/jwt.xhtml ) ou
être définies comme des URI contenant un espace
de noms pour éviter les confusions.
JWT : Payload
 Private Claims :
◦ Il s'agit des claims personnalisés créées pour partager
des informations entre des parties qui acceptent de
les utiliser et ne sont ni des réclamations
enregistrées ni des réclamations publiques.
JWT : Exemple de Payload
{
"sub": "1234567890",
"iss":"Backend",
"aud":["Web Front End","Mobile App"],
"exp":54789005,
"nbf":null,
"iat":49865432,
"jti":"idr56543ftu8909876",
"name": "pop", "roles":
["admin","author"]
}

Le payload est encodé en


Base64URL. Ce qui donne :
eyJzdWIiOiIxMjM0NTY3ODkwIiwiaXNzIjoiQmFja2VuZCIsImF1ZCI6WyJXZWIgRnJvb
nQgRW5kIiwiTW9iaWxlIEFwcCJdLCJleHAiOjU0Nzg5MDA1LCJuYmYiOm51bGwsIml
hdCI6NDk4NjU0MzIsImp0aSI6ImlkcjU2NTQzZnR1ODkwOTg3NiIsIm5hbWUiOiJtZ
WQiLCJyb2xlcyI6WyJhZG1pbiIsImF1dGhvciJdfQ
JWT : Signature
 La signature est utilisée pour :
◦ vérifier que l'expéditeur du JWT est celui qu’il
prétend être.
◦ et pour s'assurer que le message n'a pas été
modifié
en cours de route.
 Parexemple si vous voulez utiliser l'algorithme
HMAC SHA256, la signature sera créée de la
façon suivante:
◦ HMACSHA256( base64UrlEncode(header) + "."
+ base64UrlEncode(payload), secret)
JW
T
 Le JWT final est constitué des trois chaînes
Base64 séparées par des points qui peuvent
être facilement transmis tout en étant plus
compacts.

 L'exemple suivant montre un JWT qui a


l'en-tête et le Payload précédents et il est
signé avec un secret.
JWT : Exemple de JWT
https://jwt.io/
T
Client Serveur
BD
HTTP Applicatio
n
Connexion
Socke Socke
POST /Login?username
t username=x&pass=y t
SQL

200 O K Générer le Token


Index.html
JWT en calculant
Authorization : H.P..S Une signature
Déconnexion Basée sur un
secret
Nouvelle Connexion
Socke Socke
t Requête HTTP 2 : t
Vérifier la signature
POST/Save
Du JWT en
200 O K ; Bearer H.P.S
Authorization
utilisant Le secret
Réponse HTTP
Déconnexion
Comment utiliser JWT
 Au moment de l'authentification,
◦ lorsque l'utilisateur se connecte à
l'aide de ses informations
d'identification,
◦ un jeton Web JSON est renvoyé
et doit être enregistré localement
(généralement dans le stockage
local, mais les cookies peuvent
également être utilisés).
 Chaque fois que l'utilisateur veut
accéder à une route ou à une
ressource protégée, l'agent
utilisateur doit envoyer le JWT,
généralement dans l'en-tête
Authorization en utilisant le
schéma Bearer. Le contenu de
l'en- tête devrait ressembler à
ceci:
◦ Authorization: Bearer
<token>
Session ID Vs JWT

Token
s

Par Par
Référence Valeur
Session ID = JW
13 T
• A besoin d’une • N’a pas besoin d’une application
application tiers pour tiers pour connaitre les
connaitre les informations associés à ce
informations associés Token
à ce Token • Le JWT contient lui-même toutes
les informations sur l’utilisateur d’il
prétend représenter
Avantages de
JWT
Implémentations multi langages
 Java
 PHP
 Java Script
 Pyton
 .Net
 Etc ….
Problème de montée en charge.
Pas de besoin de cache partagé ou distribué
Calculer la
SessionID=1
Server
signature
1 en
Instanc
CLT e 1 utilisant le
HTTP secret
Req1 Calculer la
Server
SessionID Http signature
=12 Instanc
CLT
Serve e 2 en
Req
HTTP r utilisant le
2
Load secret
SessionID=13 Req Balance
3 r Server Calculer la
CLT
HTTP
Req Instanc signature
4 e 3 en
SessionID utilisant le
=14 Server Calculer la secret
Instanc signature
CLT e 4
HTTP en
utilisant le
Bonne solution pour les architectures
distribuées basées sur les micro services
MS1

SessionID=1
1 Proxy MS2
CLT Servic
HTTP e MS3
Req1
SessionID Http
=12
CLT
Serve
Req
HTTP r
2
Load
SessionID=13 Req Balance
3 r
CLT
HTTP
Req
4 MS4
SessionID
=14
Proxy MS5
CLT Servic
HTTP e
MS6
Secret partagé?
 Il
existe deux manière de signer le
JWT :
◦ Symétrique (Alg=HS256) avec
un secret partagé
◦ Asymétrique (Alg=RS256)avec
une clé privée : pour signer et générer les JWT
une clé publique : pour vérifier la validé des JWT
JWT dans un système distribué avec clé
privé et clé publique
MS1

Proxy MS2
CLT Servic
HTTP e MS3
Req1
Http
CLT
Serve
Req
HTTP r
2
Load
Req Balance Référentiel
3 r Des
CLT
Req Identités
HTTP
4 MS4

CLT Proxy MS5


HTTP Servic
e
MS6
Révocation des Tokens

Calculer la
SessionID=1
Server
signature
1 en
Instanc
CLT e 1 utilisant le
HTTP secret
Req1 Calculer la
Server
SessionID Http signature
=12 Instanc
CLT
Serve e 2 en
Req
HTTP r utilisant le
2
Load secret
SessionID=13 Req Balance
3 r Server Calculer la
CLT
HTTP
Req Instanc signature
4 e 3 en
SessionID utilisant le
=14 Server Calculer la
Balck secret
Instanc signature
CLT List JWT e 4
HTTP jti en
utilisant le
Ou stocker le JWT
Jeton stocké dans le sessionStorage ou dans le
localStorage du navigateur :
◦ Si le jeton est stocké de cette manière, il devra être
inclus systématiquement dans les requêtes envoyées au
serveur, par exemple via le header « Authorization:
Bearer <jeton> ».
◦ Cette solution est donc idéale pour des applications
principalement Frontend en Javascript et où celui-ci
fonctionne principalement avec des requêtes AJAX.
◦ Le développeur devra donc ajouter le jeton dans
chaque requête.
◦ Cette solution a l’avantage de protéger nativement
l’application
 contre les attaques de type CSRF.
◦ Cependant, comme le jeton doit être disponible pour
l’application JavaScript, il sera exposé en cas de faille
XSS et pourra être récupéré.
Ou stocker le JWT
 Jeton stocké dans des cookies :
◦ Lorsqu’un jeton JWT est stocké dans un cookie sur le
navigateur de l’utilisateur, il est faudrait penser de lui attribuer
les flags “HttpOnly” (et “Secure”) afin de le protéger contre
une éventuelle récupération via une attaque de type XSS.
◦ Cette solution a l’inconvénient de ne pas permettre une
authentification sur une autre application d’un autre domaine
car les cookies, par mesure de sécurité, ne peuvent être
renvoyés que sur le domaine du serveur qui les a créés.
◦ Avec un jeton stocké dans un cookie, celui-ci étant
automatiquement envoyé par le navigateur avec chaque
requête. Ce qui l’expose aux attaques CSRF
◦ Pour une prévention contre les attaques CSRF, l’une des
solution c’est d’inclure le CSRF Synchronized Token dans les
claims du JWT et resigner le JWT pour chaque réponse HTTP.
Sécuriser les JWT
 Pour les Applications Web de type Single page Application :
◦ Il faut faire attention aux attaques XSS (Cross Site Scripting)
: Injection des contenus utilisateurs
◦ Tous les points d’accès qui ne sont pas Https peuvent
exécuter
du java script et prendre le contenu des requêtes HTTP.
◦ Si vous utilisez le cookies pour stocker le JWT, penser à
envoyer le JWT en mode :
 Secure : Se passe qu’avec HTTPS
 HTTPOnly : Ne pas permettre à java script de lire le contenu
du cookie

200 OK
Set-Cookie : jwt=header.payload.signature;
Secure;HTTPOonly
Sécuriser les JWT
 Sivous stockez les JWT dans des local storages
ou cookies non sécurisé, n’importe quel script
peut voler le Token et le balancer ailleurs.
 Après, ils peuvent s’en servir pour se faire
passer pour vous (Fausse identité)
Sécuriser les JWT
Pour les applications mobile et serveurs tiers, Il
faudrait envoyer le JWT dans les entêtes
HTTP

200 O K
Autorisation : Bearer Header.Payload.Signature
Sécuriser les JWT
 Pourles attaques de type CSRF
(Cross Site Request Forgery)
◦ Pensez à mettre le Synchronizer token
(CSRF Autheticity-ID) dans le Payload du
JWT.
Autres usages des JWT
 Formulaires en plusieurs parties
◦ On peut stocker, coté serveur, les données
saisies dans la première page dans le JWT et
l’envoyer au client dans la page 2, jusqu’à la page
finale qui sera stockée coté serveur.
 Confirmation des email
◦ Comme le JWT est en base64URL, on peut
générer une JWT avec une date d’expiration
réduite (2 min par exemple) et l’envoyer par
mail sous forme d’une URL
◦ Ce qui permet d’éviter du stockage coté
serveur
pour accomplir cette opération.
Application
:

JWT et Spring
Security
Spring Security et JWT
 Créer une application qui permet de
gérer des tâches.
 L’accès à l’API REST est sécurisé d’une
manière statless, par Spring security
en utilisant Json Web Token
Architecture
Spring IOC Containner
Web Container DAO
User Task
Client HTTP, RestController
Task AppU ser
JSON
REST JWT RestController AppRole
UserRepository
Dispatcher RoleRepository
Servlet TaskRepository
SGBD
Spring Spring
Security Data

JPA
Json Web
Token Impl Hibernate

JDBC
Structure du Projet
<dependencies>
<dependency>
<groupId>or
g.springfram
ework.boot</
groupId>
<artifactId>
spring-
boot-
starter-
data-
jpa</artifac
tId>
</dependency>
<dependency>
<groupId>or
g.springfram
ework.boot</
groupId>
<artifactId>
spring-
boot-
starter-
data-
rest</artifa
ctId>
</dependency>
<dependency>
<groupId>or
Structure du Projet
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
</dependency>

<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<op t io na l >t r ue </ o pt ion a l>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>

<dependency>
<groupId>org.springframework.security </groupId>
<artifactId>spring-security-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
Authentification Spring Security avec JWT
Client Spring JWT UserDetails Account Dat
Security Authentication Filter ServiceImp a
ServiceImpl l Bas
FilterChain
HTT e
POST /Login
P { username:admin, pass:1234 }
attemptAuthentication
Authentication

loadUserByUsername
findUserByUsernam
e SQL
user
SQL
roles
user &
user & roles
roles
JWTS
cheack
passwor
successfulAuthentication
d Build JWT
Reponse Header Buil
http Autorisation : Bearer JW
J.W.T T d
Reponse
http Header JWT
Autorisation :
Bearer J.W.T
Demander une ressource nécessitant l’authentification
Client Spring Disp JWT
Autorisatio
Tasks Task Dat
Security REST s a
n Filter
API DAO Bas
FilterChain Ser
HTT v
e
POST
P /tasks
Autorisation : Bearer JWTS
J.W.T doFilterInternal(req,resp)
Sign
(JWT) Sign
username &
setAuthentication(user) roles JWT
Updatin
g
Security
/ Context / Tasks()
tasks tasks SQL
tasks
List of List of
List of tasks Tasks
Tasks
Couche Service pour la gestion des utilisateurs
package org.sid.service;
import org.sid.entities.AppRole; import org.sid.entities.AppUser;
public interface AccountService {
public AppUser saveUser(AppUser u ) ;
public AppRole saveRole(AppRole r ) ;
public AppUser findUserByUsername(String username);
public void addRoleToUser(String username,String r o l e ) ;
}

package org.sid.service;
import javax.transaction.Transactional; import org.s id.da o.*; import o r g . s i d . e n t i t i e s . * ;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
@Service
@Transacti o n
al
public class
AccountServic
eImpl
implements
AccountService
{
@Autowired
Couche Service pour la gestion des utilisateurs
@Override
public AppUser saveUser(AppUser u)
{ u.setPassword(bCryptPasswordEncoder.encode(u.getPassword(
))); return userRepository.save(u);
}
@Override
public AppRole saveRole(AppRole r )
{ return roleRepository.save(r);
}
@Override
public AppUser findUserByUsername(String username)
{ return userRepository.findByUsername(username);
}
@Override
public void addRoleToUser(String username, String roleName)
{ AppUser user=userRepository.findByUsername(username);
AppRole role=roleRepository.findByRole(roleName);
user.getRoles().add(role);
}
}
Couche Web :API REST pour gérer les taches

@RestController
public class TasksController
{ @Autowired
private TaskRepository
taskRepository;

@GetMapping("/tasks")
public List<Task> l i stTasks(){
return
taskRepository.findAll();
}
@PostMapping("/tasks")
public Task save(@RequestBody Task task)
{ return taskRepository.save(task);
}
}
Couche Web :API REST pour enregistrer de nouveaux utilisateurs

@RestController
public class UserController {
@Autowired
private AccountService accountService;

@PostMapping("/users")
public AppUser signUp(@RequestBody RegistrationForm data) {
S t r i n g username=data.getUsername();
AppUser user=accountService.findUserByUsername(username);
i f ( u s e r ! = n u l l ) throw new RuntimeException("This user already e x i s t s , Try with an other
username");
S t r i n g password=data.getPassword(); S t r i n g repassword=data.getRepassword();
if(!password.equals(repassword))
throw new RuntimeException("You must confirm your password");
AppUser u=new AppUser(); u.setPassword(password);
u.setUsername(username);
accountService.saveUser(u);
accountService.addRoleToUser(username, "USER");
return ( u ) ;
RegistrationForm.java

@Data @AllArgsConstructor @NoArgsConstructor


public class RegistrationForm
{ private String username;
private String password;
private String repassword;
}
Configuration de Spring Security

@Configuration
@EnableWebSecurity
public class SecurityConfig extends
WebSecurityConfigurerAdapter{ @Autowired
private UserDetailsService userDetailsService;
@Autowired
private BCryptPasswordEncoder
bCryptPasswordEncoder;

@Override
protected void
configure(AuthenticationManagerBuilder auth)
throws Exception {
a ut h . u se rDet ailsServ ice( userDet a ilsSe rv ic e )
.passwordEncoder(bCryptPasswordEncoder);

}
Configuration de Spring Security
@Override
protected void configure(HttpSecurity http ) throws Exception {

http.csrf().disable()
/ / d o n ' t create session

.sessionManagement().sessionCreationPolicy(SessionCreationPolicy. STATELESS)
.and()

.authorizeRequests()
.antMatchers("/users/**","/login/**")
.permitAll()
.antMatchers(HttpMethod.POST,"/tasks/**").hasAuthority("ADMIN")
.anyRequest().authenticated()
.and()
.addFilter (new JWTAuthenticationFilter(authenticationManager()))
.addFilterBefore (new JWTAuthorizationFilter(),
UsernamePasswordAuthenticationFilter.class);
Constantes de l’application

public class SecurityConstants {


public s t a t i c f i n a l String SECRET = "moitoi";
public s t a t i c f i n a l long EXPIRATION_TIME = 864_000_000; / / 10 days
public s t a t i c f i n a l String TOKEN_PREFIX = "Bearer " ;
public s t a t i c f i n a l String HEADER_STRING = "Authorization";
}
Couche Service : pour la gestion des utilisateurs
;

@Service
public class UserDetailsServiceImpl implements UserDetailsService {
@Autowired
private AccountService accountService;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
AppUser u=accountService.findUserByUsername(username);
i f(u==null ) throw new UsernameNotFoundException(username);
Collection<GrantedAuthority> authorities=new ArrayList<>();
u.getRoles().f orEach( r->{
authorities.add(new SimpleGrantedAuthority(r.getRole()));
});
return new User(u.getUsername(), u.getPassword(), authorities );
}
}
JWTAuthenticationFilter

public class JWTAuthenticationFilter extends UsernamePasswordAuthenticationFilter


{ private AuthenticationManager authenticationManager;

public JWTAuthenticationFilter(AuthenticationManager authenticationManager)


{ super();
this.authenticationManager = authenticationManager;
}
JWTAuthenticationFilter
@Override
public Authentication attemptAuthentication(HttpServletRequest request,
HttpServletResponse response) throws AuthenticationException {

AppUser user=null;
try {
user = new
ObjectMappe
r().readValue
(request.getI
nputStream()
,
AppUser.clas
s);
} catch
(Exception e )
{
throw new
RuntimeEx
ception(e);
}
return
authenticationManager.authenticate( new
UsernamePasswordAuthenticationToken(
user. getUsername( ) ,
JWTAuthenticationFilter
@Override
protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse
response, FilterChain chain,
Au t h en t ica t ion authResult) throws IOException, ServletException {

User s p rin g Us er = (Use r) aut hRe su lt . ge t Pr in c ipa l () ;


S t r i n g jwtToken =Jwt s.builder()
.setSubject(springUser.getUsername())
.setExpiration( new
Date(System.currentTimeMillis()
+SecurityConstants.EXPIRATION_TIME))
.signWith(SignatureAlgorithm. HS512,
SecurityConstants.SECRET)
.claim("roles",
springUser.getAuthorities())
. co mpact ();
r esponse.ad dHeader( Sec u r it yConstan t s . HEADER_STRIN
G,
SecurityConstants.TOKEN_PREFIX+jwtToken);
}
}
JWTAutorizationFilter

public class JWTAuthorizationFilter extends OncePerRequestFilter {

@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
FilterChain chain)
throws IOException, ServletException {

response.addHeader("Access-Control-Allow-Origin" , " * " ) ;


response.addHeader("Access-Control-Allow-Headers" , " O r i g i n , Accept, X-Requested-With,
Content-Type, Access-Control-Request-Method, Access-Control-Request-
He a d e r s , a u t h o r i z a t i on" ) ;
response.addHeader("Access-Control-Expose-Headers", " Ac c e ss - Co n t ro l- A llo w- O r ig in ,
Access-Cont rol-Allow-Credent ials, a u t h o r i z a t i o n " ) ;
if(request.getMethod().equals("OPTIONS")){
response.setStatus(HttpServletResponse.SC_OK);
}
JWTAutorizationFilter
else {
S t r i n g jwtToken=request.getHeader(SecurityConstants.HEADER_STRING);
if(jwtToken==null | | !jwtToken.startsWith(SecurityConstants.TOKEN_PREFIX)) {
c h a i n . d o F i l t e r ( r e q u e s t , response); return;
}
Claims claims =Jwt s. parser()
.setSigningKey(SecurityConstants.SECRET)
.
parseClaimsJws(jwtToken.replace(SecurityConstants.TOKEN_P
REFIX,""))
.getBody();
S t r i n g username=claims.getSubject();
ArrayList<Map<String, String>> roles=(ArrayList<Map<String, String>>)
claims.get("roles");
Collection<GrantedAuthority> authorities=new ArrayList<>();
roles.forEach(r->{
authorities.add(new SimpleGrantedAuthority(r.get("authority")));
});
UsernamePasswordAuthenticationToken authenticationToken=
new UsernamePasswordAuthenticationToken(username,
null,authorities);
Securit y Cont ex t Hold er. g et Co nt e xt ( ). se t Au t he n t ica t ion ( a ut he n t i
c at io n Token );
Application Spring Boot
;

@SpringBootApplication
public class JwtSpringApplication implements CommandLineRunner
{ @Autowired
private TaskRepository taskRepository;
@Autowired
private AccountService accountService;

public s t a t i c void main(String[] args) {


Sp r in g Ap p lic at ion. r un( Jwt Spr ing A p p lic at io n . c l a ss , args);
}
@Bean
public BCryptPasswordEncoder bCryptPasswordEncoder() {
return new BCryptPasswordEncoder();
}
Application Spring Boot
@Override
public void r u n ( S t r i n g . . . arg0) throws Exception
{ taskRepository.save(new Task(null ,"T1"));
taskRepository.save(new Task(nul l ,"T2 "));
taskRepository.save(new Task(null , "T3"));

accountService.saveRole(new AppRole(null,"USER"));
accountService.saveRole(new AppRole(null,"ADMIN"));
accountService.saveUser(new AppUser(null,"user","1234", n u l l ) ) ;
accountService.saveUser(new AppUser(null,"admin","1234", n u l l ) ) ;

accountService.addRoleToUser("user", "USER");
accountService.addRoleToUser("admin", "USER");
accountService.addRoleToUser("admin", "ADMIN");
}
}
taches
utilisateur

med@youssfi.net |ENSET Université


Hassa II
ADMIN
JWT
tâches
tâche
USER
USER
USER
Ajouter une nouvelle tâche avec le rôle
USER
Authentification Spring Security avec JWT
Client Spring JWT UserDetails Account Dat
Security Authentication Filter ServiceImp a
ServiceImpl l Bas
FilterChain
HTT e
POST /Login
P { username:admin, pass:1234 }
attemptAuthentication
Authentication

loadUserByUsername
findUserByUsernam
e SQL
user
SQL
roles
user &
user & roles
roles
JWTS
cheack
passwor
successfulAuthentication
d Build JWT
Reponse Header Buil
http Autorisation : Bearer JW
J.W.T T d
Reponse
http Header JWT
Autorisation :
Bearer J.W.T
Demander une ressource nécessitant l’authentification
Client Spring Disp JWT
Autorisatio
Tasks Task Dat
Security REST s a
n Filter
API DAO Bas
FilterChain Ser
HTT v
e
POST
P /tasks
Autorisation : Bearer JWTS
J.W.T doFilterInternal(req,resp)
Sign
(JWT) Sign
username &
setAuthentication(user) roles JWT
Updatin
g
Security
/ Context / Tasks()
tasks tasks SQL
tasks
List of List of
List of tasks Tasks
Tasks
OAuth2
OAuth2
Atelier:
Spring Cloud and Microservice
Spring vs spring boot
Spring Cloud

Spring Cloud for Spring Cloud for


Spring Cloud Bus Spring Cloud ...
Cloud Foundry Amazon Web Services

Spring Cloud Config Spring Cloud Netfix Spring Cloud Consul

Spring Cloud Context Spring Cloud Commons

Spring Boot

Spring
Spring cloud
Spring cloud
Spring Cloud Components
Configuration
Nous voulons supprimer la
configuration de l'application vers un
repo centralisé dans tous les
environnements
Spring Cloud Config Server peut
utiliser Git, SVN, le système de fichiers
et Vault pour stocker la configuration
Les clients de configuration
(applications de microservice)
récupèrent la configuration du serveur
au démarrage
Peut être notifié des changements et des
changements de processus dans un
événement de rafraîchissement
Configuration

Config Server Config Client


HTTP, API basée sur les ressources pour la Bootstrap de configuration en premier
configuration externe Bootstrap découverte
Ressources JSON / YML / propriétés Option à sécurité intégrée
Comme la lecture d'une application locale *
Git backend (par défaut)
famille .yml avec une étiquette supplémentaire
S'intègre à Spring Security «étiquette»

${spring.application.name}
/{application}/{profile}/{label}
/{application}/{profile}[/{label}] ${spring.profiles.active}
/{application}-{profile}.yml master
/{label}/{application}-{profile}.yml
/{application}-{profile}.properties
/{label}/{application}-{profile}.properties

spring.cloud.config.[name|env|label]
Service Discovery
 Étant donné la nature dynamique de toute application
native dans le cloud, le fait de dépendre d'éléments tels que
les URL peut être problématique
 Service Discovery permet aux micro-services de découvrir
facilement les itinéraires vers les services dont il a besoin
pour utiliser
Netflix Eureka
Gardien
Consul
Routing and Messaging
 Votre application native dans le cloud sera composée de
tous les microservices, la communication sera donc
essentielle
 Spring Cloud prend en charge la communication via des
requêtes HTTP ou via la messagerie
 Routage et équilibrage de charge:
 Ruban Netflix et Open Feign
 Messagerie:
 RabbitMQ ou Kafka
API Gateway
Les passerelles API vous permettent d'acheminer les
demandes d'API (internes ou externes) vers le service
approprié
 Netflix Zuul
Exploite la découverte de services et l'équilibrage de
charge
 Spring Cloud Gateway
Circuit Breakers
 L'échec est inévitable, mais vos utilisateurs n'ont pas besoin de savoir
 Les disjoncteurs peuvent aider une application à fonctionner en cas de
panne
 Netflix Hystrix
Circuit Breakers
Architecture
Architecture 1
Architecture 2
Mini projet

Customers

Shoping

Billings
Les microservices
Service de configuration
Centraliser la config du micro service

Changer le fichier de config

actuator/refresh"
Eureka Registration Service
Zuul proxy
Zuul proxy
Voir Atelier
Conclusion et discussion

Vous aimerez peut-être aussi