La mise en cache est essentielle pour atteindre des performances élevées et une grande évolutivité. Mettre en œuvre la bonne stratégie de mise en cache dès la phase de développement est essentiel pour éviter le « lag » des API et les temps de chargement des pages trop lents. Laravel est l’un des frameworks PHP les plus populaires, c’est pourquoi la mise en œuvre de la stratégie de mise en cache optimale de Laravel est indispensable pour une meilleure expérience utilisateur et un plus grand impact commercial.
Dans cet article, nous allons explorer des stratégies pour mettre en œuvre et manipuler la mise en cache dans Laravel. Vous découvrirez comment fonctionne la mise en cache Laravel, plusieurs requêtes de mise en cache Laravel et comment vous pouvez gérer la mise en cache sur les applications Laravel.
Vous tirerez davantage profit de cet article si vous avez déjà des connaissances de base sur les points suivants :
- Bonne connaissance du développement web
- Compréhension basique de Laravel
- Création d’API avec Laravel
- Compréhension basique de la mise en cache
Plongeons !
Consultez notre guide vidéo sur le cache de Laravel
Pourquoi la mise en cache est-elle importante ?
Avec le récent boom des entreprises Internet, différentes entreprises disposent de statistiques montrant comment le temps de chargement des sites web et les faibles performances peuvent avoir un impact considérable sur le SEO, l’engagement des utilisateurs et les taux de conversation sans mise en cache. Et cela commence par la mise en place d’une excellente stratégie de mise en cache.
Une étude en ligne a révélé que « 1 seconde de retard de chargement ferait perdre à Amazon 1,6 milliard de dollars de ventes par an »
Une autre étude de Google a indiqué que : « Nos recherches montrent que si les résultats de recherche sont ralentis ne serait-ce que d’une fraction de seconde, les gens cherchent moins (sérieusement : Un retard de 400 ms entraîne une baisse de 0,44 % du volume de recherche, fans de données). Et cette impatience ne se limite pas à la recherche : Quatre internautes sur cinq cliqueront ailleurs si une vidéo se bloque pendant le chargement. »
Une légère lenteur sur le temps de chargement de votre page web peut avoir un impact massif sur l’expérience de vos utilisateurs et la perte de fonds en général.
Qu’est-ce que la mise en cache Laravel ?
Laravel fournit une mise en œuvre robuste et facile à utiliser de la mise en cache et de différents backends de mise en cache. Avec Laravel cache, vous pouvez passer de manière efficace et effective d’un moteur de mise en cache à l’autre sans écrire le moindre code.
Vous pouvez trouver la configuration du cache Laravel dans le dossier config/cache.php mais vous n’aurez probablement besoin que du fichier .env pour passer d’un backend de cache à un autre.
Laravel cache fournit également de nombreuses méthodes pratiques que nous pouvons utiliser pour mettre en œuvre différentes stratégies de mise en cache.
Pilotes et comparaisons du cache de Laravel
Laravel cache fournit d’excellents backends et pilotes de mise en cache. En fonction de votre cas d’utilisation, vous pouvez passer de l’un à l’autre pour améliorer les performances et le temps de chargement de votre application.
Cela dit, Laravel cache offre aussi un moyen transparent de créer un backend personnalisé et de l’utiliser avec le cache de Laravel, mais seulement si la liste ci-dessous ne correspond pas à votre cas d’utilisation.
Nous parlerons ensuite de la liste de tous les backends fournis par Laravel cache.
1. File
Le pilote file est le backend par défaut utilisé par le cache de Laravel quand aucun pilote n’est spécifié dans le fichier .env.
Le backend file est conçu pour stocker les données mises en cache dans un fichier crypté se trouvant sous storage/framework/. Laravel crée un fichier crypté avec les données et la clé du cache lorsque de nouvelles données sont mises en cache. La même chose se produit lorsque l’utilisateur essaie de récupérer le contenu. Le cache Laravel recherche la clé spécifiée dans le répertoire et, si elle est trouvée, renvoie le contenu.
Bien que le backend file fonctionne parfaitement et permette de gagner du temps en installant et en configurant des pilotes externes, il peut aussi être parfait pour le développement. C’est plus rapide que d’accéder directement aux données du serveur de base de données.
Pour utiliser le pilote de file, ajoutez le code suivant à votre fichier .env :
CACHE_DRIVER=file2. Array
Le pilote array est un backend de mise en cache parfait pour exécuter des tests automatisés et se configure facilement avec Github Actions, Jenkins, etc.
Le backend array stocke les données mises en cache dans un tableau en PHP et ne vous demande pas d’installer ou de configurer des pilotes. Il fonctionne parfaitement pour les tests automatisés, et il est un peu plus rapide que le backend de cache file.
Pour utiliser le pilote array, ajoutez le code suivant à votre fichier .env :
CACHE_DRIVER=array3. Database
Lorsque tu utilises le pilote database, les données sont stockées en mémoire pour le processus PHP en cours. Par conséquent, vous devez créer une table de base de données pour stocker les données mises en cache. En outre, la mise en cache database améliore l’évolutivité en distribuant la charge de travail des requêtes du backend vers plusieurs frontends.
Vous pouvez exécuter cette commande Artisan – php artisan cache:table – pour générer automatiquement le schéma de base de données nécessaire au pilote database.
Le pilote database est principalement utilisé dans les situations où vous pouvez installer n’importe quel logiciel sur votre plateforme d’hébergement.
Par exemple, disons que vous utilisez un plan d’hébergement gratuit avec des options limitées. Pour cela, nous vous suggérons de vous en tenir au pilote file car le pilote database est, dans la plupart des cas, le point faible de votre application, et essayer de pousser plus de données dans ce goulot d’étranglement n’est pas une bonne idée.
Pour utiliser le pilote database, ajoutez le code suivant à votre fichier .env :
CACHE_DRIVER=database4. Redis
Le pilote Redis utilise la technologie de mise en cache basée sur la mémoire appelée Redis. Bien qu’il soit rapide par rapport aux autres pilotes de cache discutés ci-dessus, il nécessite l’installation et la configuration d’une technologie externe.
Pour utiliser le pilote redis, ajoutez le code suivant à votre fichier .env :
CACHE_DRIVER=redis5. Memcached
Memcached est connu pour être le stockage de cache basé sur la mémoire le plus populaire. Si cela ne vous dérange pas d’avoir un peu de maintenance supplémentaire sur le serveur (devoir installer et maintenir des services supplémentaires), les pilotes de cache basés sur la mémoire Memcached sont d’excellentes options.
L’utilisation du pilote memcached nécessite l’installation du paquet PECL Memcached.
Pour utiliser le pilote memcached, ajoutez le code suivant à votre fichier .env.
CACHE_DRIVER=memcached Le meilleur pilote de cache à utiliser et les performances du pilote de cache dépendent du cas d’utilisation de votre projet et de la quantité de données à récupérer.
Utilisation et méthodes de Laravel Cache
Laravel cache fournit de nombreuses méthodes précieuses utilisées pour mettre en œuvre de nombreuses stratégies de mise en cache.
Ci-dessous, nous allons énumérer et expliquer les différentes méthodes (catégorisées en fonction de leur cas d’utilisation) :
put()get()many()putMany()incrémenter()décrémente()forever()oublier()flush()remember()rememberForever()
Stockage du cache
Le stockage de nouvelles données dans le cache est très simple grâce aux différentes méthodes, chacune ayant plusieurs cas d’utilisation.
1. Cache::put()
Cette méthode accepte trois paramètres clés, duration et data à mettre en cache.
Voyons comment utiliser la méthode suivante Cache::put():
Cache::put(key, data, duration)
$post = Post::find(1) ;
Cache::put('post_1', $post, 20) ;
Le code ci-dessus mettra en cache la publication avec une clé unique pendant 20 secondes.
2. Cache::putMany()
Cette méthode stocke un tableau de données dans le cache en une seule fois avec la même durée. Elle accepte deux paramètres qui sont data et seconds.
Voyons comment utiliser la méthode Cache::putMany():
Cache::putMany(data, duration) // syntax
$posts = Post::all() ;
Cache::putMany($posts, 20) ;3. Cache::remember()
Cette méthode est un autre excellent moyen de mettre en œuvre la stratégie Aside du cache. La méthode Cache::remember() accepte trois paramètres, key, seconds et closure utilisée pour récupérer les données dans la base de données si elles ne sont pas trouvées.
Voyons comment utiliser la méthode suivante Cache::remember():
Cache::remember(key, duration, closure) // syntax
Cache::remember('posts', 20, function(){
retourne Post::all() ;
}) ;
Le cache de Laravel dispose également de la méthode Cache::rememberForever() qui n’accepte pas le paramètre seconds et stocke data pour toujours.
4. Cache::forever()
Cette méthode stocke les données dans le serveur cache pour toujours sans spécifier de durée. Vous pouvez l’implémenter avec le code suivant :
Cache::forever(key, data)
$post = Post::find(1) ;
Cache::forever('post_1', $post) ;
Récupération des données du cache
Les méthodes de cette catégorie récupèrent les données du cache. Certaines de ces méthodes peuvent se comporter différemment selon que les données sont trouvées ou non.
1. Cache::get()
Cette méthode récupère les données du serveur de cache avec une clé spécifique. Vous pouvez récupérer un élément à l’aide du code ci-dessous :
Cache::get(key) // syntax
$posts = Cache::get('posts') ;2. Cache::many()
Cette méthode est similaire à Cache::putMany(). Elle est utilisée pour récupérer un tableau de données mises en cache en une seule fois en utilisant un tableau de clés de cache. Vous pouvez récupérer un tableau de cache à l’aide du code suivant :
Cache::many(keys) // syntax
const $keys = [
'posts',
'post_1',
'post_2
] ;
$posts = Cache::many($keys) ;
3. Cache::remember()
Vous pouvez aussi utiliser cette méthode pour récupérer les données mises en cache en vérifiant le serveur de cache à l’aide de la clé fournie. Si les données sont stockées dans le cache, elle les récupérera. Sinon, il récupérera les données du serveur de base de données et les mettra en cache. Cette méthode est la même que la méthode Cache::rememberForever() avec juste un paramètre supplémentaire seconds dans la méthode Cache::remember() méthode.
Supprimer des éléments du cache
Les méthodes de cette catégorie sont utilisées pour retirer des éléments du cache, regroupées par fonctionnalité.
1. Cache::forget()
Cette méthode supprime un seul élément du cache avec un paramètre clé spécifié :
Cache::forget('key') ;2. Cache::flush()
Cette méthode vide tous les moteurs de cache. Elle supprime tous les éléments stockés n’importe où dans le cache :
Cache::flush() ;Incrémenter ou décrémenter les valeurs du cache
Vous pouvez ajuster les valeurs d’un nombre entier stocké dans votre cache en utilisant les méthodes d’incrémentation et de décrémentation, respectivement :
Cache::increment('key') ;
Cache::increment('key', $amount) ;
Cache::decrement('key') ;
Cache::decrement('key', $amount) ;
Le cache de Laravel possède de nombreuses méthodes formidables que nous n’avons pas abordées ci-dessus, mais les méthodes ci-dessus sont populaires. Vous pouvez obtenir un aperçu de toutes les méthodes dans la documentation officielle du cache Laravel.
Les commandes de cache expliquées
Laravel fournit des commandes pour rendre le travail avec le cache de Laravel facile et rapide. Vous trouverez ci-dessous la liste de toutes les commandes et leurs fonctionnalités.
Vider le cache de Laravel
Cette commande permet de vider le cache de Laravel avant même son expiration en utilisant le terminal/console. Par exemple, vous pouvez exécuter la commande suivante :
php artisan cache:clearVider Route-Cache
Cette commande est utilisée pour vider le cache route de votre application Laravel. Par exemple, exécutez la commande suivante pour vider votre cache route :
php artisan config:cacheEffacer les fichiers de vue compilés
Cette commande est utilisée pour effacer les fichiers de vue compilés de votre application Laravel. Vous pouvez y parvenir avec la commande suivante :
php artisan view:clearTableau de base de données
Lorsque vous utilises le pilote database, vous devez créer un schéma de base de données appelé cache pour stocker les données du cache. Vous pouvez aussi utiliser la commande Artisan pour générer une migration avec le schéma approprié :
php artisan cache:tableStratégies de mise en cache de Laravel
Selon le cas d’utilisation de votre application et la structure des données, plusieurs stratégies de cache différentes sont probablement à votre disposition. Vous pouvez même créer une stratégie personnalisée pour répondre à vos besoins. Ci-dessous, nous allons passer en revue la liste des stratégies de mise en cache populaires que vous pouvez mettre en œuvre dans votre projet Laravel.
writeThrough
Dans la stratégie writeThrough, le serveur de cache se trouve entre les requêtes et le serveur de base de données, ce qui fait que chaque opération d’écriture passe par le serveur de cache avant d’aller au serveur de base de données. Ainsi, la stratégie de mise en cache writeThrough est similaire à la stratégie readThrough.
Vous pouvez mettre en place cette stratégie avec le cache de Laravel avec le code suivant :
public function writeThrough($key, $data, $minutes) {
$cacheData = Cache::put($key, $data, $minutes)
// Database server is called from(after) the Cache Server.
$this->storeToDB($cacheData)
return $cacheData
}
private function storeToDB($data){
Database::create($data)
return true
}writeBack (writeBehind)
Cette stratégie est une façon plus avancée de mettre en œuvre la stratégie writeThrough en ajoutant des délais dans les opérations d’écriture.
Vous pouvez aussi l’appeler la stratégie writeBehind en raison du délai appliqué au serveur de cache avant d’écrire les données sur le serveur de base de données.
Vous pouvez mettre en œuvre cette stratégie avec le cache de Laravel avec le code suivant :
$durationToFlush = 1; // (in minute)
$tempDataToFlush = [];
public function writeBack($key, $data, $minutes){
return $this->writeThrough($key, $data, $minutes);
}
public function writeThrough($key, $data, $minutes){
$cacheData = Cache::put($key, $data, $minutes);
$this->storeForUpdates($cacheData);
retourne $cacheData;
}
// Store new data to temp Array for updatting
private function storeForUpdates($data){
$tempData = {};
$tempData['durée'] = this.getMinutesInMilli();
$tempData['data'] = data;
array_push($tempDataToFlush, data);
}
// Converts minutes to milliseconds
private function getMinutesInMilli(){
$currentDate = now();
$futureDate = Carbon(Carbon::now()->timestamp + $this->durationToFlush * 60000)
return $futureDate->timestamp
}
// Calls to update the Databse server.
public function updateDatabaseServer(){
if($this->tempDataToFlush){
foreach($this->tempDataToFlush as $index => $obj){
if($obj->duration timestamp){
if(Database::create($obj->data)){
array_splice($this->tempDataToFlush, $index, 1) ;
}
}
}
}
}La méthode writeBack appelle la méthode writeThrough, qui stocke les données sur le serveur de cache et un tableau temporaire à pousser plus tard sur le serveur de base de données à l’aide de la méthode updateDatabaseServer. Vous pouvez configurer un CronJob pour mettre à jour le serveur de base de données toutes les cinq minutes.
writeAround
Cette stratégie permet à toutes les opérations write d’aller directement sur le serveur de base de données sans mettre à jour le serveur de cache – ce n’est que pendant les opérations de lecture que le serveur de cache est mis à jour.
En supposant qu’un utilisateur veuille créer un nouvel Article, l’Article est enregistré directement sur le serveur de base de données. Lorsque l’utilisateur veut lire le contenu de l’Article pour la première fois, l’Article est récupéré sur le serveur de base de données et met à jour le serveur cache pour les requêtes suivantes.
Vous pouvez mettre en place cette stratégie avec le cache de Laravel avec le code suivant :
public function writeAround($data){
$storedData = Database::create($data);
retourne $storedData;
}
public function readOperation($key, $minutes){
$cacheData = Cache::remember($key, $minutes, function() {
return Article::all();
})
retourne $cacheData;
}
Cachement à part (chargement différé)
Dans cette stratégie, la base de données est mise de côté et l’application demande d’abord les données au serveur de cache. Ensuite, s’il y a un résultat positif (trouvé), les données sont renvoyées au client. Sinon, s’il y a un échec (non trouvé), le serveur de base de données demande les données et met à jour le serveur cache pour les requêtes suivantes.
Vous pouvez mettre en œuvre cette stratégie avec le cache de Laravel avec le code suivant :
public function lazyLoadingStrategy($key, $minutes, $callback) {
if (Cache::has($key)) {
$data = Cache::get($key) ;
return $data ;
} else {
// Database Server is called outside the Cache Server.
$data = $callback();
Cache::set($key, $data, $minutes);
retourne $data;
}
}Le code ci-dessus montre la mise en œuvre de la stratégie cache Aside, qui équivaut à la mise en œuvre de la méthode Cache::remember.
Lire à travers
Cette stratégie est l’opposé direct de la stratégie cache Aside. Dans cette stratégie, le serveur de cache se trouve entre la requête du client et le serveur de base de données.
Les requêtes vont directement au serveur de cache, et le serveur de cache est chargé de récupérer les données du serveur de base de données si elles ne sont pas trouvées dans le serveur de cache.
Vous pouvez mettre en place cette stratégie avec le cache Laravel avec le code suivant :
public function readThrough($key, $minutes) {
$data = Cache::find($key, $minutes);
return $data;
}
private function find($key, $minutes){
if(Cache::has($key) ;){
return Cache::get($key) ;
}
// Database Server is called from the Cache Server.
$DBdata = Database::find($key);
Cache:put($key, $DBdata, $minutes);
retourne $DBdata ;
}Voilà, c’est fait ! Nous avons maintenant abordé quelques stratégies de mise en cache populaires pour votre prochaine application Laravel. N’oubliez pas que vous pouvez même utiliser une stratégie de mise en cache personnalisée qui correspond le mieux aux exigences de votre projet.
Mise en cache de la partie UI d’une application Laravel
La mise en cache de l’interface utilisateur de notre application Laravel est un concept connu sous le nom de Full Page cache FPC. Ce terme désigne le processus de mise en cache de la réponse HTML d’une application.
C’est excellent pour les applications où les données HTML dynamiques ne changent pas fréquemment. Vous pouvez mettre en cache la réponse HTML pour obtenir une réponse globale et un rendu plus rapides du HTML.
Nous pouvons mettre en œuvre FPC avec la ligne de code suivante :
class ArticlesController extends Controller {
public function index() {
if ( Cache::has('articles_index') ) {
return Cache::get('articles_index') ;
} else {
$news = News::all() ;
$cachedData = view('articles.index')->with('articles', $news)->render() ;
Cache::put('articles_index', $cachedData)
retourne $cachedData
}
}
}À première vue, vous avez peut-être remarqué que nous vérifions si la page articles_index existe déjà dans notre serveur de cache. Puis nous renvoyons la page en la rendant avec les méthodes view() et render() de Laravel.
Sinon, nous effectuons le rendu de la page et stockons le résultat dans notre serveur de cache pour les requêtes suivantes avant de renvoyer la page rendue au navigateur.
Construire une application Laravel
Nous allons maintenant appliquer ce que nous avons appris jusqu’à présent en créant un nouveau projet Laravel et en implémentant le cache Laravel.
Si vous n’avez jamais utilisé Laravel, vous pouvez lire ce qu’est Laravel et jeter un œil à notre liste d’excellents tutoriels Laravel pour commencer.
Configuration de Laravel
Tout d’abord, nous allons créer une instance fraîche de Laravel à l’aide de la commande ci-dessous. Vous pouvez consulter la documentation officielle pour en savoir plus.
Ouvrez votre console et naviguez jusqu’à l’endroit où vous stockez vos projets PHP avant d’exécuter les commandes ci-dessous. Assurez-vous que Composer est correctement installé et configuré.
composer crate-project laravel/laravel fast-blog-app
// Change directory to current Laravel installation
cd fast-blog-app
// Start Laravel development server.
php artisan serve
Configurer et nourrir la base de données
Ensuite, nous allons configurer notre base de données, créer un nouveau modèle d’article et créer 500 faux points de données pour les tests.
Ouvrez votre client de base de données et créez une nouvelle base de données. Nous ferons de même avec le nom fast_blog_app_db, puis nous remplirons notre fichier .env avec les informations d’identification de la base de données :
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=fast_blog_app_db
DB_USERNAME=//DB USERNAME ICI
DB_PASSWORD=//DB MOT DE PASSE ICI
Ensuite, nous allons exécuter la commande suivante pour créer la migration et le modèle d’article simultanément :
php artisan make:model Article -mOuvrez la migration nouvellement créée trouvée database/migrations/xxx-create-articles-xxx.php et collez le code suivant :
<?php
utilise Illuminate\Support\Facades\Schema;
utilise Illuminate\Database\Schema\Blueprint;
utilise Illuminate\Database\Migrations\Migration;
class CreateArticlesTable extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('articles', function (Blueprint $table) {
$table->id();
$table->string('title');
$table->text ('description');
$table->timestamps();
}) ;
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::dropIfExists('articles') ;
}
}Ensuite, exécutez la commande ci-dessous pour créer un nouveau seeder :
php artisan make:seeder ArticleSeederOuvrez le fichier seeder nouvellement créé qui se trouve dans database/seeders/ArticleSeeder.php et collez le code suivant :
<?php
namespace Database\Seeders;
use App\Models\Article;
use Illuminate\Database\Seeder;
class ArticleSeeder extends Seeder
{
/**
* Run thz databse seeds.
*
* @return void
*/
public function run()
{
Article::factory()->count(500)->create();
}
}Ouvrez le fichier DatabaseSeeder.php dans le même répertoire et ajoutez le code suivant :
<?php
namespace Database\Seeders;
use Illuminate\Database\Seeder;
class DatabaseSeeder extend Seeder
{
/**
* Seed the application's data&base.
*
* @return void
*/
fonction publique run()
{
$this->call(ArticleSeeder::class);
}
}Ensuite, exécutez la commande ci-dessous pour créer une nouvelle Factory :
php artisan make:factory ArticleFactoryOuvrez le fichier factory nouvellement créé qui se trouve dans database/factories/ArticleFactory.php et collez le code suivant :
<?php
namespace Database\Factories ;
use App\Models\Article;
use Illuminate\Database\Eloquent\Factories\Factory;
class ArticleFactory extends Factory
{
/**
* The name of the factory's corresponding model.
*
* @var string
*/
protected $model = Article::class;
/**
* Define the model's default state.
*
* @return array
*/
public function definition()
{
return [
'title' => $this->faker->text(),
'description' => $this->faker->paragraphe(20)
];
}
}Maintenant, exécutez la commande ci-dessous pour migrer notre schéma nouvellement créé et également créer nos fausses données pour les tests :
php artisan migrate --seedCréer le contrôleur d’article
Ensuite, nous allons créer notre contrôleur et configurer nos routes pour traiter notre requête et récupérer les données à l’aide du modèle ci-dessus.
Exécutez la commande suivante pour créer un nouveau ArticlesController dans le répertoire app/Http/Controllers:
php artisan make:controller ArticlesController --resourceOuvrez le fichier et ajoutez le code suivant à la classe :
// Return all 500 articles with Caching
public function index() {
return Cache::remember('articles', 60, function () {
return Article::all();
});
}
// Return all 500 without Caching
public function allWithoutCache() {
renvoie Article::all();
}Ensuite, ouvrez le fichier api.php qui se trouve dans le répertoire routes/ et collez le code suivant pour créer un point de terminaison que nous pouvons appeler pour récupérer nos données :
Route::get('/articles', 'ArticlesController@index');
Route::get('/articles/withoutcache', 'ArticlesController@allWithoutcache');Tester les performances
Enfin, nous allons tester les performances de la réponse de notre application avec ou sans la mise en œuvre du cache de Laravel.
Cette capture d’écran montre le temps de réponse de l’API avec le cache implémenté :
La capture d’écran suivante montre le temps de réponse de l’API sans cache implémenté – notez que le temps de réponse a augmenté de plus de 5 000 % par rapport à l’instance mise en cache :
Résumé
Nous avons exploré diverses stratégies pour mettre en œuvre et manipuler le cache de Laravel en créant un nouveau projet, en évaluant ses réponses et en comparant les résultats.
Vous avez également appris à utiliser les différents pilotes et méthodes de mise en cache de Laravel. En outre, nous avons mis en œuvre différentes stratégies de mise en cache pour vous aider à déterminer celle qui pourrait vous convenir.
Pour en savoir plus sur Laravel, explorez notre sélection triée sur le volet des meilleurs tutoriels Laravel. Que vous soyez un débutant ou un développeur Laravel avancé, il y a quelque chose pour tout le monde là-dedans !
Si vous avez encore des questions sur la mise en cache Laravel, faîtes-nous en part dans la section des commentaires.
I am a Software Engineer and Content Creator who is geared toward building high-performing and innovative products following best practices and industry standards. I also love writing about it at Masteringbackend.com. Follow me on Twitter, LinkedIn, and About Me
Laisser un commentaire