Introduction
Une API REST (Representational State Transfer) est une interface qui permet de faire communiquer différentes applications entre elles via le protocole HTTP, en utilisant des opérations standard telles que GET, POST, PUT, et DELETE. Les API REST sont largement utilisées dans le développement de logiciels pour exposer des services accessibles par d'autres applications, permettant ainsi l'intégration entre différents systèmes.
Cependant, pour garantir que les APIs soient faciles à comprendre et à utiliser, une bonne documentation est essentielle. C'est là qu'OpenAPI entre en jeu.
OpenAPI est une norme de description pour les APIs RESTful. Elle permet de définir de manière structurée les fonctionnalités d'une API, en spécifiant les extrémités disponibles, les types de données acceptés et renvoyés, les paramètres requis et les réponses attendues. Toutes ces informations sont rassemblées dans un fichier de spécification (généralement avec une extension .yaml ou .json), qui peut être interprété par des outils automatisés pour générer du code, de la documentation, etc.
La spécification OpenAPI Specification est conçue pour être lisible par les machines et les humains, permettant la description, la production, la consommation et la visualisation de services web RESTful de manière standardisée. Par conséquent, un document OpenAPI représente une description formelle de l'API, utile à la fois pour les développeurs qui ont besoin de l'utiliser et pour les outils qui peuvent l'exploiter pour automatiser divers processus.
Pourquoi est-il utile de définir un fichier de spécifications?
L'adoption d'OpenAPI pour documenter une API offre plusieurs avantages, notamment:
- Clarté: elle fournit une documentation détaillée et structurée, permettant aux développeurs de comprendre rapidement comment interagir avec l'API, quelles requêtes doivent être envoyées et quelles données peuvent être attendues en réponse.
- Automatisation: la documentation peut être générée automatiquement à partir du code, et rester à jour avec tout changement d'API.
- Interactivité: des outils tels que Swagger, une suite open source de documentation et de test d'API, incluent Swagger UI. Cela vous permet d'explorer et de tester les API directement depuis le navigateur, ce qui simplifie le développement, la vérification et la compréhension des API.
- Normalisation: l'utilisation d'OpenAPI garantit que la documentation suit un format commun et reconnu, ce qui facilite l'intégration avec d'autres outils et services.
Comment créer un document OpenAPI?
Il existe deux approches principales pour générer un fichier de spécification OpenAPI:
- Approche "code-first" (automatique): si une API REST a déjà été développée dans InterSystems IRIS, vous pouvez générer automatiquement la documentation OpenAPI sans écrire de fichier de spécification manuellement.
- Approche "specification-first" (manuelle): dans ce cas, le fichier OpenAPI est écrit manuellement en YAML ou JSON, décrivant tous les points de terminaison, paramètres et réponses attendues. Cette approche est utile lorsque vous souhaitez définir l'API avant de la mettre en œuvre, ce qui facilite la conception et le partage avec d'autres développeurs ou parties prenantes.
Approche automatique
Il existe deux façons de générer automatiquement le fichier de spécification OpenAPI dans InterSystems IRIS.
Méthode 1 : Utilisation de la fonction GetWebRESTApplication
Une approche consiste à utiliser la fonction GetWebRESTApplication fournie par la classe %REST.API
.
Un exemple pratique d'utilisation consiste à ajouter la fonction suivante dans la classe de répartition:
ClassMethod GenerateOpenAPI() As %Status
{
// Le nom de l'application REST
Set webApplication = "MyAPP" // Remplacez par le nom de votre application web
// Récupérez la documentation OpenAPI 2.0
Set sc = ##class(%REST.API).GetWebRESTApplication("", webApplication, .swagger)
If $$$ISERR(sc) {
Quit sc // Si une erreur s'est produite, quittez la méthode
}
// Renvoyez la documentation au format JSON
Set %response.ContentType = "application/json"
Do ##class(OMRREST.impl).%WriteResponse(swagger.%ToJSON())
Quit $$$OK
}
ObjectScriptObjectScript
Ajoutez en outre le chemin d'accès suivant à l'UrlMap:
<Route Url="/openapi" Method="GET" Call="GenerateOpenAPI"/>
ObjectScriptObjectScript
À ce stade, vous aurez tout ce qu'il vous faut pour générer le fichier de spécification à partir de votre classe d'envoi. Pour consulter la documentation, connectez-vous à l'URL indiquée (où MyWebapp
est le nom de votre application web, tel que défini dans le portail de gestion):
<host>:<port>/MyWebapp/openapi
HTMLHTML
Le JSON ainsi généré représente la spécification OpenAPI de votre API. Après avoir exploré la deuxième méthode, nous verrons comment la visualiser et la tester dans Swagger.
Méthode 2 : Utilisation de l'API de gestion
Une autre façon de générer le fichier de spécification OpenAPI consiste à utiliser l' API de gestion InterSystems IRIS.
Pour appeler ce service, vous pouvez utiliser des outils tels que Postman, un outil de développement qui vous permet de tester, documenter et automatiser les API.
Postman fournit une interface simple et intuitive pour l'envoi de requêtes HTTP (GET, POST, PUT, DELETE, etc.), la visualisation des réponses, la gestion de l'authentification et la création de tests automatisés.
Pour formuler la requête à l'aide de Postman, procédez comme suit:
-
Cliquez sur le bouton
New
et créez une requête HTTP. - Configurez la requête comme suit et envoyez-la:
- Sélectionnez la méthode GET comme méthode HTTP.
- Spécifiez l'URL dans le format suivant, en utilisant l'
<baseURL>
de votre instance:
https://<baseURL>/api/mgmnt/v1/namespace/myapp
Ici,
namespace
est le nom de l'espace de noms où vous avez créé d le service REST, etmyapp
et le nom de votre application. - Définissez la méthode d' Authorisation sur Basic Auth et fournissez le nom d'utilisateur et le mot de passe d'un utilisateur ayant un accès en lecture à l'espace de noms spécifié.
Une fois le JSON généré, il peut être visualisé et testé à l'aide d'outils tels que Swagger Editor.
{
"info":{
"title":"",
"description":"",
"version":"",
"x-ISC_Namespace":"MyNamespace"
},
"basePath":"/MyWebapp",
"paths":{
"/loginForm":{
"post":{
"parameters":[
{
"name":"payloadBody",
"in":"body",
"description":"Request body contents",
"required":false,
"schema":{
"type":"string"
}
}
],
"operationId":"loginForm",
"x-ISC_ServiceMethod":"loginForm",
"responses":{
"default":{
"description":"(Unexpected Error)"
},
"200":{
"description":"(Expected Result)"
}
}
}
},
"/refresh":{
"post":{
"parameters":[
{
"name":"payloadBody",
"in":"body",
"description":"Request body contents",
"required":false,
"schema":{
"type":"string"
}
}
],
"operationId":"refresh",
"x-ISC_ServiceMethod":"refresh",
"responses":{
"default":{
"description":"(Unexpected Error)"
},
"200":{
"description":"(Expected Result)"
}
}
}
},
"/logout":{
"post":{
"parameters":[
{
"name":"payloadBody",
"in":"body",
"description":"Request body contents",
"required":false,
"schema":{
"type":"string"
}
}
],
"operationId":"logout",
"x-ISC_ServiceMethod":"logout",
"responses":{
"default":{
"description":"(Unexpected Error)"
},
"200":{
"description":"(Expected Result)"
}
}
}
},
"/openapi":{
"get":{
"operationId":"GenerateOpenAPI",
"x-ISC_ServiceMethod":"GenerateOpenAPI",
"responses":{
"default":{
"description":"(Unexpected Error)"
},
"200":{
"description":"(Expected Result)"
}
}
}
}
},
"swagger":"2.0"
}
JSONJSON
Approche manuelle
L'approche manuelle pour générer un document OpenAPI consiste à écrire manuellement le fichier de spécification au format YAML ou JSON. Cette approche est particulièrement utile lorsque vous souhaitez contrôler entièrement la conception de l'API avant sa mise en œuvre, ou lorsque vous documentez une API déjà existante sans recourir à des outils automatisés.
Pour rédiger le fichier de spécification OpenAPI, vous pouvez vous référer à , la documentation officielle de la version 2.0 de la spécification OpenAPI, où vous trouverez des renseignements sur les champs obligatoires et sur la manière de décrire les points de terminaison, les paramètres, les réponses, etc. Ce guide détaillé vous aidera à comprendre comment structurer correctement le fichier YAML ou JSON afin de respecter les normes OpenAPI.
Un bon exemple d'utilisation de cette approche est la création d'un service REST à l'aide des méthodes décrites dans la documentation officielle d'InterSystems IRIS.
Vous trouverez une introduction au développement et à la configuration d'une application REST dans IRIS sur cette page de la documentation, qui décrit étape par étape les méthodes nécessaires pour exposer une application RESTful avec IRIS.
Merci pour la traduction, ça aide pour ceux qui sont moins à l'aise en anglais 😁
Il manque juste le lien pour la documentation sur le dernier paragraphe
Merci pour votre commentaire ! J'ai ajouté un lien vers la documentation 😊