){kind=small}
Comment envoyer un SMS avec l'API minimale de .Net 6
Temps de lecture : 5 minutes
Cela fait un certain temps que je regarde les versions préliminaires de .Net 6, et l'une des fonctionnalités les plus intéressantes dont beaucoup de gens parlent est celle des API minimales. Bien que les avis semblent très partagés, je pense qu'il s'agit d'un ajout bienvenu. Il supprime une grande partie du poids de l'utilisation d'ASP.NET MVC et abaisse certainement la barre d'entrée avec une sensation similaire à ExpressJS dans NodeJS.
Il y a un peu plus d'un an, nous avons publié un billet de blog intitulé "Comment envoyer un SMS avec ASP.NET Core MVC". Avec la sortie de .Net 6, j'ai pensé que ce serait une bonne idée de s'inspirer et de voir ce que cela donnerait d'utiliser la nouvelle syntaxe Minimal API pour émuler la même fonctionnalité.
Vous pouvez passer directement au code sur GitHub.
.Net 6 RC 2 SDK ou supérieur
Visual Studio 2022 Preview ou Visual Studio Code
To complete this tutorial, you will need a Vonage API account. If you don’t have one already, you can sign up today and start building with free credit. Once you have an account, you can find your API Key and API Secret at the top of the Vonage API Dashboard.
La façon la plus simple que j'ai trouvée pour créer un nouveau projet Minimal API est d'utiliser la commande suivante
dotnet new web -o SmsDotnetMinimalApiMicrosoft propose également un excellent tutoriel sur la création d'un nouveau projet Minimal API à l'aide de Visual Studio.
Nous devrions maintenant avoir une API avec un point de terminaison "Hello World". Pour cela, nous allons ajouter deux paquets NuGet, le premier étant SDK .Net de Vonage de Vonage, version 5.9.2 au moment de la rédaction. Comme il s'agit d'une API, nous n'aurons pas d'interface utilisateur, le second est Swashbuckle / Swagger qui nous permettra d'essayer facilement tous les points de terminaison que nous créerons.
dotnet add package Vonage
dotnet add package Swashbuckle.AspNetCore
En plus des éléments habituels appsettings.jsonvotre projet nouvellement créé ne comportera qu'un seul fichier, Program.cs. C'est vraiment minimal, du moins pour un projet ASP.Net.
.Net 6 Project
Ouvrons Program.csIl devrait ressembler à ceci.
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/", () => "Hello World!");
app.Run();C'est tout ce dont vous avez besoin pour avoir une API .NET complète dans un seul fichier. Cela fournira un point de départ beaucoup plus léger pour construire une petite API ou un microservice. Et pour être honnête, j'ai encore du mal à me souvenir de la quantité de code nécessaire à WebAPI pour produire le même résultat.
Commençons par ajouter quelques paramètres. A l'intérieur appsettings.json nous devons ajouter notre clé et notre secret Vonage, ceux-ci sont utilisés pour authentifier votre application avec les services de Vonage et peuvent être trouvés en haut du tableau de bord.
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
"Vonage_key": "ab12c3de",
"Vonage_secret": "ZKSQ1vlzNvyZnQCI"
}Actuellement, nous n'avons pas configuré l'injection de dépendance. Ajoutons donc la classe VonageClient à la collection de services. Cela lui permettra d'être injectée dans n'importe quelle classe ou méthode que nous utiliserons plus tard.
Importez les espaces de noms requis en tête du fichier.
using Vonage;
using Vonage.Messaging;
using Vonage.Request;Enregistrer le VonageClient dans la collection de services.
builder.Services.AddSingleton<VonageClient>(provider =>
{
var config = provider.GetRequiredService<IConfiguration>();
var key = config.GetValue<string>("Vonage_key");
var secret = config.GetValue<string>("Vonage_Secret");
var credentials = Credentials.FromApiKeyAndSecret(key, secret);
return new VonageClient(credentials);
});En procédant ligne par ligne, nous pouvons voir que nous obtenons une instance de IConfiguration, ce qui nous permet d'accéder aux paramètres de l'application dont nous avons besoin. La clé et le secret sont ensuite récupérés de la configuration afin que nous puissions créer les informations d'identification requises par le constructeur de VonageClient.
Maintenant que notre classe VonageClient est configurée et prête à être injectée, créons un nouveau point de terminaison vers lequel nous pourrons envoyer des requêtes. Nous aurons besoin de passer un modèle de données au point de terminaison, donc créons une classe dans un nouveau fichier appelé `SmsModel`. Ensuite, à l'intérieur de la classe, nous voulons ajouter les propriétés suivantes.
public class SmsModel
{
public string To { get;set; }
public string From { get;set; }
public string Text { get;set; }
}Une fois notre modèle créé, nous pouvons ajouter une nouvelle méthode POST avec le VonageClient et notre classe SmsModel comme paramètres.
app.MapPost("/sms", async (VonageClient vonageClient, SmsModel smsModel) =>
{
var smsResponse = await vonageClient.SmsClient.SendAnSmsAsync(new SendSmsRequest
{
To = smsModel.To,
From = smsModel.From,
Text = smsModel.Text
});
});Il se passe plusieurs choses dans ce bloc de code. Tout d'abord, nous utilisons la méthode MapPost pour créer un point de terminaison à l'adresse http://localhost:5000/sms. Deuxièmement, nous déclarons les paramètres de la méthode ; VonageClient sera injecté en utilisant l'injection de dépendance que nous avons mise en place précédemment, SmsModel sera créée en utilisant le corps de la requête à l'aide de la méthode liaison de modèle.
Le corps de la méthode se charge d'envoyer le SMS. Nous créons une instance de SendSmsRequest en utilisant les données du modèle que nous avons passé, puis il suffit de passer la classe de requête à la méthode SmsClient SendAnSmsAsync du SmsClient. Dans l'esprit du "minimum", il n'y a qu'une seule ligne !
Le projet devrait maintenant se construire, s'exécuter et recevoir des requêtes. Comme mentionné précédemment, nous n'avons pas d'interface utilisateur pour tester cela facilement. Nous allons donc ajouter quelques lignes de code pour implémenter l'interface utilisateur Swagger dans notre projet.
Directement après var builder = WebApplication.CreateBuilder(args), nous devons ajouter deux lignes de code. Celles-ci ajouteront les services nécessaires à l'injection de dépendance.
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();Une fois ces éléments ajoutés, nous enregistrons l'intergiciel Swagger avant la ligne app.Run() ligne
app.UseSwagger();
app.UseSwaggerUI();
app.Run();Maintenant que tout notre code est écrit, nous pouvons lancer le projet, en appuyant sur F5 si vous utilisez Visual Studio ou en exécutant la commande ci-dessous dans le dossier du projet.
dotnet runNaviguez maintenant jusqu'à https://localhost:5001/swagger et vous devriez pouvoir utiliser le bouton "Try it out" sur le point de terminaison SMS. Vous obtiendrez alors un code de réponse 200 et recevrez un message texte.
La validation des entrées est une partie vitale de toute API, mais en l'état actuel des choses, il n'y a pas de validation intégrée dans les API minimales, comme c'est le cas avec ASP.NET MVC. Damian Edwards a créé une petite bibliothèque appelée MinimalValidation qui utilise des attributs de validation similaires à la validation MVC.
Personnellement, je préfère Validation fluide car elle utilise le code pour définir les règles plutôt que les attributs. Un exemple de ceci est ci-dessous, pour le code complet incluant la validation, consultez le dépôt sur GitHub.
Enregistrement des services et modifications des points d'extrémité
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
// validation
builder.Services.AddValidatorsFromAssemblyContaining<SmsModel>(ServiceLifetime.Scoped);
...
app.MapPost("/sms", async (VonageClient vonageClient, SmsModel smsModel, IValidator<SmsModel> validator) =>
{
ValidationResult validationResult =validator.Validate(smsModel);
if (!validationResult.IsValid)
{
return Results.ValidationProblem(validationResult.ToDictionary());
}
var smsResponse = await vonageClient.SmsClient.SendAnSmsAsync(new SendSmsRequest
{
To = smsModel.To,
From = smsModel.From,
Text = smsModel.Text
});
return Results.Ok();
});Valideur de modèle
public class SmsModel
{
public string To { get; set; }
public string From { get; set; }
public string Text { get; set; }
public class Validator : AbstractValidator<SmsModel>
{
public Validator()
{
RuleFor(x => x.To).NotEmpty().WithMessage("To phone number required");
RuleFor(x => x.From).NotEmpty().WithMessage("From phone number required");
}
}
}Extension de la validation
public static class ValidationExtensions
{
public static IDictionary<string, string[]> ToDictionary(this ValidationResult validationResult)
=> validationResult.Errors
.GroupBy(x => x.PropertyName)
.ToDictionary(
g => g.Key,
g => g.Select(x => x.ErrorMessage).ToArray()
);
}
Alors que MVC est un cadre entièrement fonctionnel qui intègre la liaison et la validation des modèles, des pipelines extensibles via des filtres, des comportements basés sur des conventions et des déclarations, etc. Certains peuvent ne pas avoir besoin de fonctionnalités spécifiques ou avoir des contraintes de performance qui rendent l'utilisation de MVC indésirable. Avec de plus en plus de fonctionnalités apparaissant en tant qu'intergiciel ASP.NET Core (autorisation, authentification, routage, etc.), ASP.NET 6 et les API minimales apportent ces fonctionnalités en jeu avec moins de pompe et sont parfaitement adaptées à la création de microservices légers de manière opportune et facile à maintenir.
Le code de ce tutoriel est disponible sur GitHub
Microsoft Aperçu des API minimales
Gist de David Fowler Aperçu des API minimales
Ce que les gens Tweet à propos de Minimal APIs