L’Outil Surpuissant pour Exploser ton Chiffre d'Affaires en 2025 !
Votre premier microservice dans .NET 6
Plus qu'un mot à la mode, les microservices sont là pour rester et gagnent actuellement en popularité en raison de leur acceptation sur le marché du développement de systèmes. Dans cet article, nous allons explorer quelques fonctionnalités intéressantes disponibles sur la plate-forme .NET et créer notre premier microservice.
Les résultats obtenus récemment montrent que l'architecture basée sur les microservices peut être une excellente option lors de la mise en œuvre de nouvelles fonctionnalités.
Ceci est due à la polyvalence des microservices, qui, bien que relativement nouveaux, présentent déjà d'excellents résultats et leur utilisation a connu une croissance exponentielle, en particulier ces dernières années. Avec l'évolution de la plate-forme .NET, qui en est actuellement à sa sixième version, la mise en œuvre des microservices est devenue encore plus simple.
Dans cet article, nous allons passer un peu de temps à définir les « microservices » puis nous créerons un microservice à partir de scratch.
Que sont les microservices ?
Bien qu'il n'y ait pas de définition exacte de ce que sont les microservices, sur la base de ce que Martin Fowlerl'une des plus grandes références sur le sujet aujourd'hui, dit, les microservices peuvent être utilisé pour décrire une façon de concevoir des applications logicielles composées de petits ensembles de services qui fonctionnent et communiquent les uns avec les autres indépendamment, consentant à un seul concept. En plus de son fonctionnement, la mise en œuvre des microservices se fait également de manière indépendante.
Pourquoi des microservices ?
On peut dire que les microservices sont à l'opposé des monolithes, et il y a beaucoup de discussions sur ce qui serait idéal. Il existe de nombreuses raisons d'utiliser des monolithes, Fowler lui-même est un défenseur des monolithes, mais concentrons-nous sur les avantages de l'utilisation de microservices.
Les microservices facilitent le développement, le test et le déploiement de parties isolées d'une application. Chaque microservice peut être mis à l'échelle indépendamment selon les besoins. Votre implantation est également simple et n'a pas besoin de dépendre d'autres parties.
Chaque microservice utilise sa propre base de données, réservée à son propre périmètre, ce qui évite les nombreux problèmes pouvant survenir à partir de deux ou plusieurs systèmes utilisant la même base de données. .
Évidemment, les microservices ne résolvent pas tous les problèmes et présentent également des inconvénients. L'un d'eux est la complexité créée par la division d'un module en plusieurs microservices. Malgré certains inconvénients, les résultats obtenus principalement ces dernières années montrent que les systèmes avec des architectures basées sur des microservices obtiennent d'excellents résultats.
ASP.NET Core et Microservices
Comme d'autres plates-formes de développement, Microsoft a investi massivement pour répondre aux exigences de une architecture basée sur des microservices. Aujourd'hui, .NET fournit de nombreuses ressources à cette fin.
Le site Web officiel de Microsoft contient de nombreux contenus sur l'architecture basée sur les microservices, notamment des livres électroniques, des didacticiels, des vidéos et des défis pour aider les développeurs à les utiliser.[19659003]Avec .NET 6, le développement d'applications dans une architecture de microservices est devenu encore plus facile grâce à la nouvelle fonctionnalité d'API minimales qui simplifie de nombreux processus qui étaient autrefois obligatoires mais qui ne sont plus nécessaires.
Approche pratique
Dans cet article, nous allons créer un microservice simple, qui effectue une requête dans une API et renvoie ces données dans la réponse.
Créer le projet
À suivre ce tutoriel, vous devez télécharger et installer le .NET SDK (Software Development Kit), en version 6.
Vous pouvez accéder au code source complet sur ce lien : Source Code.
Le la structure finale du projet sera comme f ollows :
Dans votre invite de commande, exécutez la commande suivante pour créer votre projet d'API minimal :
dotnet new web -o UserManager -f net6.0
Que signifient ces commandes ?
- La commande « dotnet new web » crée une nouvelle application de type API Web (c'est un point de terminaison d'API REST).
- Le paramètre « -o » crée un répertoire nommé UserManager où votre application est stockée.
- La commande "-f net6.0" permet d'informer la version .NET que nous utiliserons.
Ouvrez maintenant le fichier "UserManager.csproj" généré à la racine du projet avec votre IDE préféré – ce didacticiel utilise Visual Studio 2022.
Et puis nous avons la structure suivante générée par la commande précédente. Il s'agit d'un framework d'API minimal standard dans .NET 6.
Créer le microservice
L'API minimale que nous avons créée contient déjà tout ce dont nous avons besoin pour commencer à implémenter notre microservice, qui aura la structure suivante :
/Solution.sln
|
|---- UserManager.API.Default <-- API publique
| |---- Program.cs <-- Injection de dépendances
| |---- /Points de terminaison
| | |---- UserEndpoints.cs <-- Points de terminaison API
|---- UserManager.Application <-- Couche pour l'exposition du référentiel et des services
| |---- /Contracts <-- Contrats exposés au client
| | |---- /v1 <-- Version
| | | |---- /Users <-- Classes de requêtes et de réponses
| | | | |---- /Réponse
| | | | | |---- GetUsersResponse.cs
| |---- /Services
| | |---- /v1 <-- Version
| | | |---- IUserConfigService <-- Interface de service
| | | |---- UserConfigService <-- Classe de service
Dans Visual Studio, renommez le projet de « UserManager » en « UserManager.API.Default ». Ensuite, faites un clic droit sur le nom de la solution et suivez la séquence suivante :
Ajouter –> Nouveau projet… –> Bibliothèque de classes –> Suivant –> (Mettez le nom : « UserManager.Application ») — > Suivant –> .NET 6.0 –> Créer
Nous avons créé la couche d'exposition du référentiel et des services. Nous allons maintenant créer les contrats qui sont exposés au client. Dans le projet UserManager.Application, créez un nouveau dossier et renommez-le avec « Contracts ». « GetUsersResponse », et remplacez le code généré par celui-ci :
public record GetUsersResponse
{
public List<User> Users { get; set;[19659046]} = new List<User>();
public record User
{
public int id { get; set; }
public string nom { get; set; }
public string nom d'utilisateur { get; set; }
public string email { get; set; }[19659055]public Adresse adresse { get; set; }
public string téléphone { get; set; }
public string site Web { get; set;[19659046]}
public Company company { get; set; }
}
public record Adresse s
{
public string street { get; set; }
public string suite { get; set; }
public string city { get; set; }
public string code postal { get; set; }[19659055]public Geo geo { get; set; }
}
public record Geo
{
public string lat { get; set; }
public string lng { get; set; }
}
public record Company
{
public string name { get; set; }
public string catchPhrase { get; set; }
public string bs { get; ensemble; }
}
}
Cette classe a une liste d'utilisateurs, qui contiendra les données reçues dans la réponse à la requête.
Créons maintenant la classe de service qui contiendra les règles métier du microservice.
Toujours dans le UserManager.Application projet, créez un nouveau dossier et renommez-le avec « Services ». À l'intérieur, créez un dossier appelé « v1 ». Dans la v1, créez une nouvelle interface appelée « IUserConfigService » et remplacez le code généré par celle-ci :
public interface IUserConfigService
{
public Task<GetUsersResponse> GetAllUsersAsync();
public Task<GetUsersResponse]1994]y[19455990] (int id);
}
Et créez une classe appelée « UserConfigService » et remplacez le code généré par ceci :
using Newtonsoft.Json;
using static GetUsersResponse;
public class UserConfigService : IUserConfigService
{
privé lecture seule HttpClient _httpClient;
public UserConfigService(HttpClient httpClient)[194559109]
_httpClient = httpClient;
}
public async Tâche<GetUsersResponse> Get[196590sA19659043])
{
var userResponse = new GetUsersResponse();
var[1945904] uri [1945904] = "https://jsonplaceholder.typicode.com/users";
var responseString = wait _httpClient.GetStringAsync[19659043](uri);
var utilisateurs = JsonConvert.DeserializeObject<List <User>>(responseString);
userResponse.Users = users;
return userResponse;
}
public async Task<GetUsersResponse> GetUserByIdAsync(int id)
{
var [19455904] new GetUsersResponse();
var uri = $"https://jsonplaceholder.typicode.com/users?id ={id}";
var responseString = wait _httpClient.GetStringAsync(uri)[19659043];
var utilisateurs = JsonConvert.DeserializeObject<List<User>[19659050>(responseString);
userResponse.Users = users;
return userResponse;
}
}
Vous devrez installer la bibliothèque « Newtonsoft.Json ». Vous pouvez le faire via Visual Studio.
Explication
Tout d'abord, nous avons créé une interface qui contiendra les principales méthodes du service. Ensuite, nous avons créé la classe de service utilisateur, qui implémentera ces méthodes.
Dans la méthode "GetAllUsersAsync", notre service récupérera une liste d'utilisateurs du site "jsonplaceholder.typicode.com", qui fournit une fausse API gratuite pour les tests et le prototypage. Il renverra une liste d'utilisateurs. Ce processus se fera via une requête avec la classe "HttpClient" qui fournit des méthodes de communication entre les API. correspondant.
Dans les deux cas, le retour de l'API est converti en une liste d'utilisateurs compatible avec l'enregistrement Utilisateur du contrat.
Création des Endpoints
Il faut maintenant créer les endpoints qui utiliseront le méthodes de service. Dans .NET 6, nous n'avons plus besoin d'un « contrôleur », nous allons donc créer une classe qui implémentera les points de terminaison.
Ainsi, dans le projet « UserManager.API.Default », créez un nouveau dossier appelé « Endpoints », et à l'intérieur, créez une classe appelée « UserEndpoints ». Remplacez ensuite le code généré par celui-ci :
public static class UserEndpoints
{
public static void MapUsersEndpoints( cette application d'application Web)
{
app.MapGet("/v1/users", GetAllUsers);
app.MapGet("/v1/users/{id}", GetUserById);
}
public static void AddUserServices(this IServiceCollection service)
{
service.AddHttpClient<IUserConfigService, UserConfigService>();
}[19659054]interne static IResult GetAllUsers(IUserConfigService service)
{
var utilisateurs = service .GetAllUsersAsync().Result.Users;
return utilisateurs est pas null ? Résultats.Ok(users) : Résultats.NotFound ();
}
interne statique IResult GetUserById(IUserConfigService service, int[19459004)
{
var utilisateur = service.GetUserByIdAsync(id).Résultat.Users.SingleOr]Default ();
retour utilisateur est pas null ? Résultats.Ok(utilisateur) : Résultats.NotFound();
}
}
Vous devrez ajouter dans le projet « UserManager.API.Default » la dépendance du projet « UserManager.Application ». C'est facile, il suffit de cliquer avec le bouton droit sur le fichier "Dépendances" du projet "UserManager.API.Default" –> "Ajouter une référence de projet…" et de choisir le projet "UserManager.Application"
Explication
Dans la classe ci-dessus, nous créons les points de terminaison dans la méthode "MapUsersEndpoints".
La méthode "AddUserServices" injectera la dépendance du service et de son interface, et les deux autres méthodes utilisant le service renvoient le résultat de la recherche, si est nul, un statut « NotFound » sera affiché dans la réponse.
Maintenant, dans la classe Program, nous allons ajouter les paramètres de service et de swagger. Remplacez donc le code du fichier Program.cs par le code ci-dessous.
var builder = WebApplication.CreateBuilder(args);
constructeur.Services.AddUserServices();
builder.Services.AddEndpointsApiExplorer();
constructeur.Services.AddSwaggerGen();
var application = constructeur.[19659236]Construire();
app.MapUsersEndpoints();
if (app.Environnement.IsDevelopment[19659043]())
{
app.UtilisezSwagger();
app.UtiliserSwaggerUI();
}
app.Utiliser la redirectionHttps();
application.Exécuter();
Vous devrez installer la bibliothèque « Swashbuckle.AspNetCore ». Vous pouvez le faire via Visual Studio.
Et dans le fichier « launchSettings.json » sous le paramètre "launchBrowser": trueajoutez ceci :
"launchUrl": "swagger"
Il y a deux endroits, à l'intérieur de « profils » et « IIS Express ».
Enfin, notre microservice est prêt à fonctionner. Si vous l'exécutez dans Visual Studio en utilisant l'option "IIS Express", vous obtiendrez le résultat suivant dans votre navigateur.
Maintenant, si vous accédez aux adresses https ://localhost : et https://localhost :vous obtiendrez les résultats suivants :
Conclusion
Dans cet article, nous avons eu une introduction au sujet « microservices » et nous avons créé un microservice simple en .NET 6 qui communique avec une autre API et affiche les données utilisateur.
Les possibilités de travail avec des microservices sont infinies, alors n'hésitez pas à implémenter plus de fonctions dans le projet, telles que les méthodes de création et de mise à jour, la communication avec une base de données, les validations, les tests unitaires et bien plus encore .
Source link