Création d’un projet en symfony

1- Création du projet
2- Aller dans le dossier du projet
3- Installer les prérequis du projet
4- Paramétrage d’accès à la base de donnée
5- Faire la migration (faire partir des classes pour générer réellement les requête sql)
6- Application de la migration pour générer les données dans la base de données
NB :
Le contrôleur c’est la table qui permet de manipuler les données
- API
- Le fichier api plateforme pour faire les API
- Avoir php8
- Version composeur 1.5
- Symfony 8

RAPPORT DU COURS ORM (Le Mapping Objet-Relationnel:

ORM Cas sqlAlchemy)
ORM signifie "Object-Relational Mapping". C'est un concept qui consiste à utiliser une couche
d'abstraction pour accéder à une base de données relationnelle depuis un langage de programmation
orienté objet. L'ORM mappe les classes de modèles sur des tables de la base de données, en utilisant
des annotations ou des fichiers de configuration.
On commence par installer l’environnement de développement :
 apt install python3 python3-pip mariadb-server ;
 pip3 install sqlachemy ;
 pip3 install pymysql ;
Installer php sous ubuntu 18

#pip3 install sqlachemy

#pip3 install pymysql

On doit faire des mises à jours pour préparer l’environnement de travail et d’installation des paquets
#apt –y upgrade
Installation du module repository ppam :ondrej/php

On fait ENTREE pour continuer l’installation

Installation de php8.2

Après l’installation on peut vérifier la version de PHP par la commande suivante :

#php –V

Installons composer : on peut l’installer en ligne de commande comme nous montre la figure ci-
dessous ou sur son site par le lien https://getcomposer.org/download.
Mais d’abord il faut installer php-cli qui permettra l’installation de composer

Installation de composer

On renomme composer.phar en composer

Ensuite voir la version de php qu’utilise note machine, et pour cette version installer curl pour
permettre à php d’utiliser curl
#cd /etc/php

Dans mon cas le système utilise php 7.2 donc on va installer php7.2-curl
#apt install php7.2-curl

Installation de symfony (https://symfony.com/download)

Installation du serveur maria dB

Installation des paquets

Installation des modules nécessaires

#composer require jms/serializer-bundle
#composer require friendsofsymfony/rest-bundle
#composer require symfony/maker-bundle

#composer require symfony/orm-pack

Tous les prerequis et paquets ayants installés, nous allons créer un projet avec le software symfony
Création d’un projet avec symfony : créons le projet cadeau
#symfony new cadeau

Allons dans le dossier généré pour installer les paquets

Installons l’api plateforme

#composer req api

Installons le paquet php-xml pour remédier à ce problème
#apt install php-xml

#composer req api

On redemarre le server symfony

Et faire localhost:8000 dans le navigateur pour voire l’interface de symfony

On édite le fichier .env et on renseigne les paramètres de connexion à notre base de données

Création de la base de donnée

#php bin/console doctrine :database :create

Création de l’entité Clients

#php bin/console make :entity
Après la création de l’entité, nous fais la migration avec la commande suivante :
#php bin/console make :migration
Après on applique la migration avec la commande :
#php bin/console doctrine:migations:migrate ou encore (php bin/console d:m:m)

Pour notre projet on va créer un utilisateur syriack avec un password passer et lui donner tous les
droits.

Vérification de notre base de donnée créée avec symfony

Affichons la table Clients créée avec symfony

On constate qu’il est possible d’y ajouter insérer les informations

Après avoir fini toutes les étapes, on redemarre symfony. Ensuite dans la barre de recherche faire :
localhost:8000/api interface de notre api platform que nous pouvons utiliser.

On met l’id de l’utilisateur que l’on souhaite avoir ses informations ou les modifier
Insertion d’un nouveau client par la méthode POST

On voir que le message de réception est 200 ce qui signifie que le client est créé avec succès

Modification des informations avec PUT

Suppression total avec DELETE : on met l’id du client que l’on veut supprimer et on valide
Utilisation de PATCH pour modifier ou supprimmer partiellement une information

Pour voir les entités de la base de donnée créer en ligne de commande on fait comme suivant :
On édite par exemple l’entité étudiant

Dans Controller est vide on vérifie dans Reportory

 FAIRE UN PROJET SYMFONY AVEC CRUD
Création d’un projet crud

On se déplace dans notre dossier crée

Installation de l’ORM doctrine :

#composer require symfony/orm-pack

#composer require --dev symfony/maker-bundle

Éditons le fichier .env
#nano .env

On installe les services suivants

Création de la base de donnée

#php ./bin/console doctrine:database:create

Création de la classe President qui sera mappée sur la table president de notre base
Après la création de la base de donnée et ses entités, on crée maintenant la migration
#php bin/console make:migration

#php bin/console doctrine:migrations:migrate

Vérifions la migration
On fait la mise en place d’un crud

Correction d’erreur

Pour administrer notre CRUD, on installe profiler

#composer req profiler
Mise en place d’un crud
#php bin/console make:crud

On redémarre symfony
On va enfin sur le navigateur pour voir notre projet crud

On clique sur create new pour insérer les clients, ensuite on remplit les cases puis on sauvegarde par
Save.

Affichage de la liste des clients

On va créer un nouveau client Syriack que nous allons modifier ses informations
Modifions les informations de Syriack

On vérifie dans la base de donnée en ligne de commande

Teste de connexion de notre entité de base de donnée en ligne de commande avec curl
 UTILISATION DE SYMFONY SUR WINDOWS
Installation sur Windows
On commence par installer l’environnement administrateur power Shell si ce n’est pas encore installer
sur notre machine

Les logiciels à installer comme prérequis sont :

 Php8.2
 Xampp
Après on télécharge le logiciel composer et on l’installe
Fin d’installation de composer

Sur notre terminal on tape la commande composer pour initier les fonctionnalités du logiciel
Faire php –v pour vérifier la version de php

On installe composer on ligne de commande par la commande suivante :

On ouvre notre Windows PowerShell et on installe scoop qui va nous permettre de prendre en compte
les commandes linux sur Windows pour l’installation de symfony.
On installe symfony avec :
scoop install symfony-cli

On vérifie la version de notre symfony avec la commande

symfony -V

Création du projet cadeau avec symfony new

On voit qu’il nous faut installer d’abord le logiciel git pour que symfony prend en compte la création
du projet.
scoop install git

Comme on peut voir sur la figure ci-dessous on doit créer un compte mail et renseigner son nom
On crée le mail et on enregistre le nom

On peut créer maintenant notre projet on change le nom cadeau d’avant par projet
symfony new projet

Installation de l’api plateforme

symfony req api

On doit avoir la même interface ci-dessous si tout va bien

La commande dir permet de vérifier la ou est notre projet crée

On édite le fichier .env pour configurer

notepad.exe .env

On commente la partie en bleue en ajoutant # devant la ligne et on ajoute la ligne en jaune

On crée l’utilisateur syriack dans notre base de donnée de XAMPP et on lui donne les droits comme
suivant:

On crée réellement notre base de donnée école

php .\bin\console doctrine :database :create

Créons l’entité Etudiants ainsi que le repository EtudiantsRepository

php bin\console make:entity
On doit installer composer req symfony maker-bundle - -dev comme le montre le message d’erreur ;

On crée à nouveau notre entité Etudiants

Gênerons le fichier de migration qui est en fait un script SQL qui sera utilisé pour générer la table
étudiant quand on va appliquer migrate à la commande suivante
php bin\console make:migration

Appliquons la migration pour la génération effective des données dans la base

On vérifie dans la base de donnée pour être sûr que la migration s’est bien passée
Démarrons notre serveur de développement

Dans le navigateur on tape : localhost:8000/api pour accéder à l’interface de notre api comme le
montre la figure suivante :

Vérifions nos informations api dans la base de donnée

>desc etudiant ;

Insertion d’une entité par POST avec notre api

Vérification dans la base de donnée

Insertion des autres entités

Affichons les insertions dans la base de donnée

On modifie le nom, noteCotrole et noteDevoir de israel mette

Vérification

On crée un autre utilisateur et on le supprime

Résultat dans la base de donnée

On va supprimer l’étudiant leonel messi avec DELETE

On voit que leonel messi a été supprimer

Avec PATCH on peut supprimer partiellement les informations comme noteControle et noteDevoir
de l’étudiant syriack flavien

Ça donne le résultat suivant :

 AJAX PHP CRUD
Prérequis :

 mariadb-server ou mysql-server
 php, php-json,php-mysql,php-xml
Création de la base php_ajax, la table
employees(id,prenom,nom,numetudiant,notecontrole,notedevoir), de l’utilisateur toto avec le mot de
passe passer avec tous les droits sur la base php_ajax

Création de la table employees

1. Création du programme principal employee.php

2. fichier de connexion
 3. Fichier employee-add.php
4. Fichier employee-list.php
5. Fichier employee-view.php
6. Fichier employee-edit.php
7. Fichier employee-delete.php
Pour afficher l’interface de notre php ajax_crud on tape l’url dans le navigateur ensuite on obtient

SECURISER UNE API PLATFORM

Création d’un projet banque symfony

On accède à notre projet crée et on affiche le contenu

Insertion des données mysql

Création de notre base de donnée

# composer req maker-bundle

Créons les entités de la base de donnée

On fait la migration

Appliquons la migration de notre base de donnée

On applique la méthode crud

Pour pouvoir administrer notre API on installe :
# composer req "admin"

# symfony console make:admin:dashboard

# symfony console make:admin:crud

On édite le fichier suivant et on y ajoute ces modifications

# nano src/Controller/Admin/DashboardController.php

Création de l’entité user

# php bin/console make:migration

# php bin/console doctrine:migrations:migrate

On se connecte à notre base de donnée et on vérifie les tables qu’on a générées

MariaDB [(none)]> use caisse ;
MariaDB [caisse]> show tables;

MariaDB [caisse]> desc user;

# php bin/console make:auth

# php bin/console make:registration

# nano src/Security/AppCustomAuthenticator.php
On accède a notre interface crud et insérons quelques utilisateurs

Affichons le client dans notre base de donnée MariaDB

On édite le fichier security.yaml et on définit le terme de sécurité d’accès à notre application

On enregistre les noms qui seront les noms administrateurs qui pourront se connecter et avoir accès
aux données

On affiche les noms dans la base de donnée puis on les donnes le rôle d’administrateur

MariaDB [banque]> update user set rôles='["ROLE_ADMIN"]' where id=1;

Dans le navigateur on se connecte avec les comptes admin

Utilisation de bootstrap 5 pour styliser un template

On se place dans le projet ensuite dans templates
On édite le fichier base.html.twing. Pour le styliser avec bootstrap on y ajoute le lien et les sous
fichiers template hériterons de ce style

Stylisation du fichier new.html.twig du templates

#nano new.html.twig

On obtient le résultat suivant

On modifie le fichier edit.html.twig

#nano edit.html.twig

Modification du fichier show.html.twig

#nano show.html.twig

Modification du fichier _delete.html.twig

Essayons de styliser notre bouton Delete

#nano _delete.html.twig

Stylisation du fichier client

On peut également accéder à ces données par le login et on obtiendra les mêmes résultats

On obtient

Partie PDO
Comme prérequis il faut installer les paquets suivants

 Curl
  Php-curl
 Php-json
 Php-mysql

On crée une base de donnée et un utilisateur dont on lui donne tout les droits sur la base de donnée

Créons le dossier de notre projet

#mkdir tp6

Création du fichier de connexion

# nano connexion.php

Fichier de connexion crud

#nano crudpdo.php
On crée dans la base de donnée une table client avec les identifiants

Insertion des parametres de la base de donnée dans notre fichier de connexion crudpdo.php

Création du client avec la fonction create de crudpdo.php par la méthode curl

Vérification dans la base de donnée

Exécuter de la fonction lecture

Vérification avec curl à la ligne de commande

On peut afficher sous forme de tableau, pour ce faire dans la fonction lecture() on supprime la partie
json_encode

On ajoute un second utilisateur et on reprend la commande

On l’affiche sous forme d’un tableau

La fonction update

Il s’agit de modifier le solde de l’utilisateur Macky Sall à 5000000 au lieu de 30000000

Vérification
La fonction delete

Vérification

Création d’un service

On commence par crée notre projet symfony
Téléchargement du module http-client
#composer req http-client

On se déplace dans /src et on y crée un dossier Service

On créé un controller Home avec la commande suivante :

#php bin/console make :controller Home

On édite le fichier HomeController.php et on ajoute :

Use App\Service\CallApiService ;
On vérifie l’existence du dossier Home

Faire du CRUD avec Doctrine

Créer un nouveau projet symfony
#symfony new cruddoctrine –full

Installer l’utilitaire Maker-Bundle et créer l’entité Client

#composer req maker-bundle

#php bin/console make:entity

Paramétrage de la connexion à la base de données il faut modifier le fichier .env pour renseigner le
Database URL (DSN + Compte utilisateur)
#nano .env

Créer la base de données et les tables

#php bin/console d:d:c
#php bin/console make:migration

#php bin/console d:m:m

Créer le contrôleur html/cruddoctrine

#php bin/console make:controller Noir
 UTILISATION DE HTMX
Configurer HTMX
Pour configurer HTMX, vous pouvez apparemment le charger via un CDN et l'ajouter à votre balise
principale comme ceci ci-dessous :
Automatiser le rafraichissement de la page à chaque modification, on utilise la syntaxe :
« hx-trigger=’’every 3s’’ »
On ajoute la syntaxe dans le fichier base qui contient le cdn HTMX

Le code php à rafraichir

#nano bonjour.php

On tape dans le navigateur « premier.html au lieu de bonjour.php »

Deuxième modification

Résultat

Vous pouvez également installer HTMX via npm comme ceci ci-dessous :
On installe npm qui nous permettra d’installer à son tour htmx

#npm install htmx.org

On crée un dossier sourcehtmx dans lequel on y copiera la source htmx

On modifie la source de htmx dans premier.html et on obtient les mêmes résultats

Mettons en place une application PHP CRUD avec PDO et requêtes préparées avec notre HTMX.
Dans le navigateur on tape :
Localhost/htmx/navigation.html

On crée un compte avec notre application

On a le message suivant

On clique sur afficher pour voir le client crée

Versons 50 000 sur le compte de syriack flavien en cliquant sur Verser de notre application

Supprimons le compte de toto

Résultat
 MISE EN PLACE D’UNE INTERFACE DE CONSOMMATION AVEC HTTP-CLIENT
Mettre en place une API avec API plateforme
#symfony new projet

#composer req api

#php bin/console d :d :c

#composer req maker-bundle

#php bin/console make :entity

#php bin/console make :migration

#php bin/console d :m :m
Fichier de connexion

On vérifie la route http://localhost:8000/ajoutnoir du Controller qui fait appel à la méthode createnoir.

On enregistre les noms dans notre base de donnée dès l’interface de notre route

On vérifie dans notre base de donnée Apitp

Et comme on voit l’utilisateur a été enregistrer. On peut y ajouter autant que l’on veut
Test affichage : Test de la route /home du Controller qui fait appel à la méthode affichetout de notre
conteneur de service. http://localhost:8000/home

Test de modification
Test de la route http://localhost:8000/modifnoir du Controller qui fait appel à la méthode modifnoir de
notre conteneur de service. http://localhost:8000/modifnoir

On vérifie
Test de suppression
Test de la route http://localhost:8000/deletenoir du Controller qui fait appel à la méthode deletenoir.
http://localhost:8000/deletenoir

Sécurité des applications dans symfony : Api Platform et

JWT
Sachant que symfony et composer sont déjà installer :
On crée d’abord un nouveau projet (api_platform)
#symfony new noirApi --full

On se déplace dans le projet et on installe le maker-bundle

#composer req maker-bundle
On édite le fichier .env et on ajoute nos identifiants pour créer la base de données :
#nano .env

On crée la base de donnée avec la commande suivante :

#php bin/console d :d :c

On va créer une ressource qui se sera une table contenant les informations des clients
#php bin/console make :entity

On crée la migration avec la commande :

#php bin/console make :migration
Ensuite on applique la migration avec php bin/console d:m:m (doctrine:migrations:migrate)
pour créer la table
#php bin/console d :m :m

II – Api-platform
Pour intégrer l’Api-Platform dans le projet Symfony on tape la commande composer require
api
#composer req api
Dans le fichier src/Entity/Client.php sur la deuxième ligne, on nous demande si on veut
exposer l’entité en tant que ressource dans Api Platform on rajoute les deux lignes (use
ApiPlatform\Metadata\ApiResouce et #[ApiResource])
Les 2 lignes suivantes indiquées en jaune

Et nous avons l’interface de notre api

Dans ce fichier on paramétrer la route d’accès à l’api on peut changer api par le nom de notre
projet par exemple
#nano config/routes/api_platform.yaml

On redémarre le projet pour voir si notre entité a bien été exposée dans Api Platform

III. Authentification JWT dans Api Platform

Pour générer un jeton JWT on crée d’abord des utilisateurs pour l’authentification. Symfony
dispose d’un composant user et d’un formulaire d’inscription pour cela. On génère la table «
user »
#php bin/console make :user
Ensuite on crée et on applique la migration
#php bin/console make :migration
#php bin/console d :m :m

On fait également make:registration. Ce composant va ajouter une route

IP_server:8000/register pour s’inscrire
#php bin/console make :registration

On choisit la route où l’on sera redirigé après s’être enregistré

Installation de LexikJWTAuthenticationBundle JWT
#composer req jwt-auth

Création de la double clé de sécurité avec la commande suivante

#php bin/console lexik :jwt :generate-keypair

On ouvre le fichier .env pour vérifier les paramètres du keypair généré. La précédente
commande ajoute les informations suivantes dans .env
Ensuite on modifie le fichier config/packages/security.yaml :
On va dans config/packages/security.yaml pour que l’accès à la ressource /api/accueil exige
un jeton JWT valide

Puis on déclare la nouvelle route d’authentification dans le fichier config/routes.yaml :

On ajoute d’un point de terminaison dans Api Platform pour récupérer un jeton JWT On et
également l’identifiant de notre token JWT dans le fichier
config/packages/lexik_jwt_authentication.yaml :
On ajoute l’autorisation d’authentification par token JWT dans Swagger en créant le fichier
config/packages/api_platform.yaml qui va ajouter le bouton « Authorize » qui permettra
d’ajouter le token dans l’entête des requêtes dans Api Platform.

On redémarre notre serveur

Puis on se rend sur la page web dans la route /register (http://127.0.0.1:8000/register) pour
créer un utilisateur : syriack@ec2lt.sn
On valide en cliquant sur Register qui va nous rediriger vers la route choisie lors de la
commande make:registration 2 pour api_docs

Si on regarde bien on voit que les verbes http sur l’entité Client sont dans la route /api/clients
or dans security.yaml on avait verrouillé cette route (exigeant un token)

Essayons de crée un client pour voir si on va nous demander le token pour avoir accès
On constate qu’il nous génère un message d’erreur

➢ Authentification via Api Platform

On va s’authentifier pour recevoir un token JWT sur l’endpoint /api/authentification_token :
On clique sur Execute pour recevoir un jeton. Sur la capture ci dessous on voit bien qu’un
token a été généré

Ajout du Token dans les entêtes

Il faudra cliquer sur Authorize (en haut à gauche) et coller le token.
NB : mettre Bearer avant de coller le token
On clique sur Authorize puis close

Vérifions voir si notre table de la base de donnée contient des clients. Comme on le voit il y a
zéro
Après l’authentification du Token retentons maintenant de créer un client

On voit que notre client a été créé avec succès

Vérifions à nouveau dans notre base de donner si le client existe

En conclusion l’utilisateur créé existe bel et bien.

IV - Authentification JWT avec Postman

Il faut d’abord avoir installer postman si nous il n’est pas encore installé
#snap install postman

Sur postman, dans l’onglet Headers on choisit le type Content-Type application/json

Dans body on choisit également raw et JSON et on donne les identifiants de connexion

On clique sur Send pour s’authentifier

Utilisation du token Sur Postman
Dans l’onglet Authorization on choisit le type Bearer Token et on renseigne le token généré
plus haut.

Requête Get avec Token

On constate qu’on a accès aux ressources
Si on renseigne un mauvais Token les ressources seront indisponibles et l’application envoie
un message d’erreur

JWT Refresh
Pour ajouter cette fonctionnalité à notre application Symfony, nous allons installer et
configurer le composant gesdinet/jwt-refresh-token-bundle.

Activons le bundle

Configurez la classe de jeton d’actualisation. Créez le fichier avec le contenu cidessous:

config/packages/gesdinet_jwt_refresh_token.yaml
On configure le fichier RefreshToken.php en ajoutant les 2 lignes suivantes :

Créez la classe d’objets (entité).

On crée l’entité et la nomme RefreshToken On appuie sur entrée pour ne pas créer de champs
:

On fait la migration pour créer la table refresh_tokens

Notre nouvelle table vient d’être créée

Configurer l’authentificateur
Pour activer l’authentificateur, on doit l’ajouter à notre pare-feu API à côté des
authentificateurs. On rajouter les lignes en jaune dans security.yaml La configuration
complète du pare-feu doit ressembler à ce qui suit :

Définir l’itinéraire du jeton d’actualisation

On édite le fichier de configuration de routage et on y ajoute l’itinéraire suivant :
Test
On fixe le time to live (durée de validité) du token à 2 minutes.

On démarre symfony et on renseigne les information d’authentification pour generer les deux
token suivant:
’’token’’
’’refresh_token’’
On voit dans corps de la réponse qu’on a un token et un refresh_token. Le token_refresh est
stocker dans la base de données et dispose d’une durée de validé d’un mois

Simulation : On attend 2 minutes pour essayer d’accéder à la ressource protéger

http://127.0.0.1:8000/api/clients

On nous signale que le token a expiré :

Maintenant au lieu de fournir un login-motdepasse, on va juste présenter le token_refresh sur
l’url /api/token/refresh pour obtenir un nouveau token

On voit qu’on a reçu un nouveau token qu’on va pouvoir utiliser pour accéder aux ressources
protégées.

Création d’une interface de consommation d’API

1- Etape: Exposé l’entité Client en tant que ressource à consommer (manipulation
CRUD)
2- Etape: Protéger la ressource avec JWT
3- Etape: Manipuler les données avec le JWT (Bearer)
http-Client
Création de service
mkdir src/Service

On crée le fichier TokenService.php dans le service

Création des Contrôleurs

Editer le fichier src/Entity/Clients et commenter ou supprimer les lignes

use ApiPlatform\Metadata\ApiResource
#[ApiResource]
On édite le fichier ClientController.php et on remplace le code
Création du controller de consommation : ConsoclientController

On édite le fichier ConsoClientController.php

 Api platform, API REST manuel, documentation openAPI,
CORS, htmx et sécurité avec jwt

Partie I : Génération d’une API à partir d’une entité avec api plateforme
1- Création d’un projet
2- Création d’une entité
3- Installer api plateform
4- Ajouter 2 lignes dans la classe de notre entité pour obtenir l’api use
ApiPlatform\Metadata\ApiResource; Au-dessus de la classe 1 #[ApiResource]
5- Paramétrer la route d’accès à l’API dans config/routes/api_plateforme,yaml ( c’est
déjà fait)
Génération d’une API à partir d’une entité avec api plateforme

Partie II : Développer une API manuellement

Ont créé notre projet fosrest
#symfony new fosrest --full

On se déplace dans notre projet installe les modules

#composer req symfony/maker-bundle

Modification du fichier .env

Création de la base de donnée
#php bin/console d :c :c

On crée les entités

#php bin/console make :entity

Création et application de la migration

#php bin/console make :migration
#php bin/console d :c :c
Création de contrôleur faisant CRUD

On édite le contrôler et on ajoute les 3 lignes suivantes :

use App\Entity\Client;
use App\Repository\ClientRepository;
use Doctrine\ORM\EntityManagerInterface;

Partie III - Gestion de la documentation d’une API à l’aide

de openAPI
On installe les modules nelmio/api-doc-bundle, twig, asset
#composer require nelmio/api-doc-bundle
#composer require twig asset

Configuration d’openAPI dans le fichier config/packages/nelmio_api_doc.yaml

On importe les classes nécessaires dans notre contrôleur ClientController.php comme

suivant :
use Nelmio\ApiDocBundle\Annotation\Model;
use Nelmio\ApiDocBundle\Annotation\Security;
use OpenApi\Attributes as OA;

Puis on fait appel à des attributs pour faire apparaître les exemples de données à envoyer à
chaque méthode de notre API
On édite config/routes/nelmio_api_doc.yaml et on décommette :

Partie IV - Sources d’origine croisée : CORS

#composer require nelmio/cors-bundle

On édite le fichier nelmio_cors.yaml et on ajoute 'hx-current-url','hx-request' comme le

montre la figure suivante :
# nano config/packages/nelmio_cors.yaml
On accède à notre api on tapant localhost :8000/api/doc dans le navigateur

On constate maintenant qu’on peut utiliser htmx pour consommer l’api

D’après la documentation de symfony if faut ajouter le contenu de

config/packages/nelmio_cors.yaml Pour utiliser LexikJWTAuthenticationBundle
On va créer notre premier client par l’interface de notre api

La réponse envoyée montre que l’utilisateur a été créé avec succès

Ensuite on va vérifier dans notre base de donnée l’utilisateur crée

On voit que le client créé existe bien dans notre base de donnée. Et on peut en créer plus que
l’on veut.

Partie V - Sécuriser l’accès à l’API grâce à un jeton de

sécurité JWT
On va commencer par l’installation de jwt-auth
# composer req jwt-auth
Générer la paire de clés ainsi que la paraphrase :
On crée le dossier des clés jwt
#php bon/console lexik :jwt :generate-pairkey

Nous pouvons vérifier l’existence des deux clés générées dans config/jwt.

On vérifie également les paramètres de jwt dans le fichier .env

Création de la classe d’authentification User (make:user) créons l’entité user pour les
utilisateurs qui seront appelés à s’authentifier pour avoir le token jwt
#php bin/console make :user
On fait la migration et on l’applique

Nous allons ensuite vérifier la création de la table user en ligne de commande

Ensuite dans la base de donnée

Création du système d’enregistrement (make:registration)

#php bin/console make:registration
On démarre le serveur symfony

Nous allons renseigner une adresse mail et un mot de passer pour avoir accès aux
informations de la base de données

Normalement après avoir renseigner et cliquer sur Register la page nous redirigera vers
lecture, car nous avons choisi tout à l’heure 16 ‘’lecturenoir’’ dans note registration
Accès à la lecture ressources

Affichons l’user créer et ses informations

Paramétrage d’authentification par jwt dans security.yaml

#composer require –dev symfony/profiler-pack
On ajoute les lignes suivantes sous firewall

On ajoute dans config/routes.yaml les paramètres suivants

On ajoute dans le fichier config/packages/lexik_jwt_authentication.yaml

En utilisant postman on ajoute le mail et password et on voit qu’il nous génère le token

On copie et colle le Token dans l’entête pour afin avoir accès à la fonction lecture qui va nous
afficher la liste des clients comme avec register

On doit avoir le résultat ci-dessous

NB : s’il n’y a pas de token l’accès aux informations des clients sera impossible