text stringlengths 0 3.99k | embedding listlengths 768 768 | metadata dict |
|---|---|---|
[
0.012244656682014465,
0.03951353579759598,
-0.007785385008901358,
0.002132065361365676,
0.0466049499809742,
0.012159234844148159,
0.03977908566594124,
0.04207943007349968,
-0.02076347917318344,
-0.03903520107269287,
0.024283483624458313,
-0.008056382648646832,
-0.049722351133823395,
0.0171... | {
"azure_component": "network",
"chunk_index": 900,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "669",
"source_file": "API_Management.pdf",
"total_pages": 1973
} | |
Importer une API gRPC
05/06/2025
S’APPLIQUE À : Développeur | Premium
Cet article montre comment importer une définition de service gRPC tant qu’API dans API
Management. Vous pouvez ensuite gérer l’API dans API Management, sécuriser l’accès, puis
appliquer d’autres stratégies, puis transmettre des requêtes d’API gRPC via la passerelle vers le
serveur principal gRPC.
Pour ajouter une API gRPC à API Management, vous devez :
Charger le fichier de définition Protobuf (mémoire tampon de protocole) de l’API dans
API Management
Spécifier l’emplacement de votre service gRPC
Configurer l’API dans API Management
API Management prend en charge la méthode Pass-through avec les types de méthodes de
service gRPC suivants : type unaire, diffusion en continu du serveur, diffusion en continu du
client et diffusion en continu bidirectionnelle. Si vous souhaitez en savoir plus sur gRPC,
consultez Présentation de gRPC
.
Une instance API Management. Si vous n’en avez pas déjà une, suivez ce guide de
démarrage rapide : Créer une instance Azure API Management.
Ressource de passerelle approvisionnée dans votre instance. Le cas échéant, veuillez
consulter la rubrique Approvisionner une passerelle auto-hébergée dans Azure API
Management.
Fichier Protobuff (.proto) gRPC disponible localement et service gRPC accessible via
HTTPS.
７ Notes
Actuellement, les API gRPC sont prises en charge dans la passerelle auto-hébergée
uniquement, pas dans la passerelle managée de votre instance API Management.
Actuellement, le test des API gRPC n’est pas pris en charge dans la console de test
du portail Azure, ni dans le portail des développeurs API Management.
L’importation est limitée à un seul fichier Protobuff (.proto).
Prérequis | [
-0.020372498780488968,
-0.025241132825613022,
-0.04345696046948433,
0.011027093976736069,
-0.0017003853572532535,
0.05418683588504791,
0.01824779622256756,
0.01077170018106699,
-0.04788294434547424,
-0.067337267100811,
-0.014798453077673912,
-0.051434144377708435,
-0.05877504497766495,
0.0... | {
"azure_component": "network",
"chunk_index": 901,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "670",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
1. Dans le portail Azure
, accédez à votre instance API Management.
2. Dans le menu de gauche, sélectionnez API>+ Ajouter une API.
3. Sous Définir une nouvelle API, sélectionnez gRPC.
4. Dans la fenêtre Créer une fenêtre d’API gRPC, sélectionnez Complète.
5. Pour une API gRPC, vous devez spécifier les paramètres suivants :
a. Dans Charger un schéma, sélectionnez un fichier .proto local associé à l’API à
importer.
b. Dans URL du serveur gRPC, entrez l’adresse du service gRPC. L’adresse doit être
accessible via HTTPS.
c. Dans la liste Passerelles, sélectionnez la ressource de passerelle que vous
souhaitez utiliser pour exposer l’API.
6. Entrez les paramètres restants pour configurer votre API. Ces paramètres sont
expliqués dans le tutoriel Importer et publier votre première API.
7. Sélectionnez Créer.
Ajouter une API gRPC
Portail
） Important
En préversion publique, vous ne pouvez sélectionner qu’une passerelle auto-
hébergée. La passerelle managée n’est pas prise en charge. | [
-0.030157778412103653,
-0.017669757828116417,
-0.043658800423145294,
0.0026618659030646086,
0.008925558999180794,
0.06722697615623474,
-0.004073594696819782,
0.027252832427620888,
-0.029780805110931396,
-0.0857449322938919,
-0.030450768768787384,
-0.01990526355803013,
-0.06063665822148323,
... | {
"azure_component": "network",
"chunk_index": 902,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "671",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
L’API est ajoutée à la liste des API. Vous pouvez afficher et mettre à jour vos
paramètres en accédant à l’onglet Paramètres de l’API.
Pour plus d’informations sur l’appel de services gRPC avec .NET, consultez les articles suivants :
Tutoriel : Créer un client et un serveur gRPC en ASP.NET Core
Résoudre les problèmes de gRPC sur .NET
Vous pouvez composer une API à partir d'API exposées par différents services, notamment :
Une spécification OpenAPI
Une API SOAP
Une API GraphQL
Une application web hébergée dans Azure App Service
Les fonctions Azure
Azure Logic Apps
Azure Service Fabric
Pour ajouter une API à une API existante :
1. Accédez à votre instance Azure API Management dans le portail Azure :
Appeler les services gRPC avec .NET
Ajouter d’autres API
７ Notes
Lorsque vous importez une API, les opérations sont ajoutées à votre API actuelle.
| [
-0.02700435370206833,
-0.04802506044507027,
-0.023279614746570587,
-0.006922950502485037,
-0.011989586055278778,
0.05275959149003029,
0.031083516776561737,
0.03198784217238426,
-0.04275684431195259,
-0.0639365166425705,
-0.03539395332336426,
-0.06025000661611557,
-0.09331813454627991,
0.00... | {
"azure_component": "network",
"chunk_index": 903,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "672",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
2. Sélectionnez API dans la page Vue d’ensemble, ou sélectionnez API>API dans le menu
de gauche.
3. Sélectionnez les points de suspension (...) à côté de l’API à laquelle vous souhaitez ajouter
une autre API.
4. Sélectionnez Importer dans le menu déroulant :
5. Sélectionnez un service à partir duquel importer une API.
| [
-0.03020903840661049,
-0.031955450773239136,
-0.01948666013777256,
-0.03701602667570114,
0.02029002457857132,
0.03201301023364067,
-0.010660480707883835,
0.02571430243551731,
-0.07743100076913834,
-0.0696110650897026,
-0.03042089380323887,
-0.004227094817906618,
-0.03056272491812706,
0.017... | {
"azure_component": "network",
"chunk_index": 904,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "673",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Limites de l’importation d’API
Importer une spécification OpenAPI
Importer une API SOAP
Importer une API SOAP et la convertir en REST
Importer une API App Service
Importer une API d’application conteneur
Importer une API WebSocket
Importer une API GraphQL
Importer un schéma GraphQL et configurer des résolveurs de champs
Importer une API d’application de fonction
Importer une API d’application logique
Importer un service Service Fabric
Importer une API Azure AI Foundry
Importer une API Azure OpenAI
Importer une API LLM
Importer une API OData
Importer des métadonnées OData SAP
Importer une API gRPC
Modifier une API
Contenu connexe | [
-0.04627758637070656,
-0.005916980095207691,
-0.0315505713224411,
-0.007819658145308495,
0.03415768966078758,
0.04729114845395088,
0.029497534036636353,
0.04945692420005798,
-0.029348138719797134,
-0.05549930781126022,
-0.013117535971105099,
-0.04973948746919632,
-0.08111948519945145,
0.00... | {
"azure_component": "network",
"chunk_index": 905,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "674",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Configurer une API pour les événements
envoyés par le serveur
Article • 08/04/2024
S’APPLIQUE À : Développeur | Essentiel | Essentiel v2 | Standard | Standard v2 |
Premium
Cet article fournit des instructions pour la configuration d’une API dans Gestion des API
qui implémente des événements envoyés par le serveur (SSE). Les SSE s’appuient sur la
norme HTML5 EventSource pour transmettre (push) automatiquement des données à
un client via HTTP après que celui-ci ait établi une connexion.
Disposer d’une instance d’API Management. Si vous ne l’avez pas déjà fait, créez-
en un.
Une API qui implémente les SSE. Importez et publiez l’API sur votre instance
Gestion des API à l’aide de l’une des méthodes d’importation prises en charge.
Suivez ces instructions lors de l’utilisation de Gestion des API pour atteindre une API
back-end qui implémente des SSE.
Choisir un niveau de service pour les connexions HTTP longues : SSE s’appuie sur
une connexion HTTP longue prise en charge dans certains niveaux tarifaires de
Gestion des API. Les connexions longues sont prises en charge dans les niveaux de
Gestion des API classique et v2, mais pas dans le niveau Consommation.
Maintenir en vie les connexions inactives : Si une connexion entre le client et le
serveur principal peut rester inactive pendant quatre minutes ou plus, implémentez
un mécanisme pour maintenir la connexion en vie. Par exemple, activez un signal
Conseil
Gestion des API offre également une prise en charge native des API WebSocket,
qui maintiennent ouverte une connexion bidirectionnelle unique et persistante
entre un client et un serveur.
Prérequis
Instructions pour les SSE | [
-0.031785134226083755,
-0.03863958269357681,
-0.02072879672050476,
-0.05077364668250084,
-0.0067480942234396935,
0.02546692080795765,
0.05364277586340904,
0.01994691975414753,
-0.048804741352796555,
-0.05974278971552849,
-0.023425035178661346,
-0.04091500863432884,
-0.07672693580389023,
0.... | {
"azure_component": "network",
"chunk_index": 906,
"contains_sku": true,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "675",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
TCP KeepAlive sur le serveur principal de la connexion, ou envoyez du trafic du
côté client au moins une fois toutes les quatre minutes.
Cette configuration est nécessaire pour remplacer le délai d’inactivité de la session
de quatre minutes appliqué par l’équilibreur de charge Azure, qui est utilisé dans
l’infrastructure de Gestion des API.
Relayer immédiatement les événements aux clients : Désactivez la mise en
mémoire tampon des réponses sur la stratégie forward-request afin que les
événements soient immédiatement relayés aux clients. Par exemple :
XML
Éviter les autres stratégies qui mettent en mémoire tampon les réponses :
Certaines stratégies, telles que validate-content, peuvent également mettre en
mémoire tampon le contenu des réponses et ne doivent pas être utilisées avec les
API qui implémentent les SSE.
Évitez la journalisation du corps de requête/réponse pour Azure Monitor,
Application Insights et Event Hubs – vous pouvez configurer la journalisation des
requêtes d’API pour Azure Monitor ou Application Insights à l’aide des paramètres
de diagnostic. Les paramètres de diagnostic vous permettent de journaliser le
corps de la requête/réponse à différentes étapes de l’exécution de la requête. Pour
les API qui implémentent SSE, cette action peut provoquer une mise en mémoire
tampon inattendue qui peut entraîner des problèmes. Les paramètres de
diagnostic pour Azure Monitor et Application Insights configurés dans l’étendue
des API globales/Toutes s’appliquent à toutes les API du service. Vous pouvez
remplacer les paramètres des API individuelles si nécessaire. Lorsque vous vous
connectez à Event Hubs, vous configurez l’étendue et la quantité d’informations de
contexte pour la journalisation des demandes/réponses à l’aide des log-to-
eventhubs. Pour les API qui implémentent SSE, vérifiez que vous avez désactivé la
journalisation du corps des requêtes/réponses pour Azure | [
-0.006450024899095297,
-0.06209457665681839,
-0.045329269021749496,
-0.004373309668153524,
0.020003149285912514,
0.01158001646399498,
0.045557837933301926,
0.04346165060997009,
-0.06426598131656647,
-0.06454967707395554,
0.003578789299353957,
-0.026739003136754036,
-0.08244933187961578,
0.... | {
"azure_component": "network",
"chunk_index": 907,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "676",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
les paramètres des API individuelles si nécessaire. Lorsque vous vous
connectez à Event Hubs, vous configurez l’étendue et la quantité d’informations de
contexte pour la journalisation des demandes/réponses à l’aide des log-to-
eventhubs. Pour les API qui implémentent SSE, vérifiez que vous avez désactivé la
journalisation du corps des requêtes/réponses pour Azure Monitor, Application
Insights t Event Hubs.
Désactiver la mise en cache des réponses : Pour garantir la rapidité des
notifications au client, vérifiez que la mise en cache des réponses n’est pas activée.
Pour plus d’informations, consultez Stratégies de mise en cache de Gestion des
API.
<forward-request timeout="120" fail-on-error-status-code="true" buffer-
response="false"/> | [
-0.01815692149102688,
-0.024774475023150444,
-0.02791830524802208,
-0.02126411721110344,
0.023503035306930542,
0.04829657822847366,
0.031866587698459625,
0.048683714121580124,
-0.06392426043748856,
-0.044149354100227356,
0.003953658975660801,
-0.04529283568263054,
-0.07518346607685089,
0.0... | {
"azure_component": "network",
"chunk_index": 908,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "676",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Tester l’API sous charge : Suivez les pratiques générales pour tester votre API sous
charge afin de détecter les problèmes de performances ou de configuration avant
de passer en production.
En savoir plus sur la configuration des stratégies dans Gestion des API.
En savoir plus sur la capacité de gestion des API.
Étapes suivantes | [
0.003960026428103447,
-0.010359513573348522,
-0.021146096289157867,
0.003012734930962324,
0.036408089101314545,
0.028905732557177544,
-0.0024819832760840654,
0.03821725398302078,
-0.044760894030332565,
-0.039990004152059555,
0.00174190872348845,
0.01048775389790535,
-0.05974198877811432,
-... | {
"azure_component": "network",
"chunk_index": 909,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "677",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Restrictions et problèmes connus relatifs
à l’importation d’API
Article • 26/04/2024
S’APPLIQUE À : Tous les niveaux de Gestion des API
Lors de l'importation d'une API, il se peut que vous rencontriez certaines restrictions ou
que vous deviez identifier et rectifier des problèmes avant de pouvoir réussir
l'importation. Cet article porte sur les points suivants :
Comportement de Gestion des API pendant l’importation OpenAPI.
Limitations de l’importation OpenAPI et fonctionnement de l’exportation OpenAPI.
Exigences et limitations de l’importation WSDL et WADL.
Lors de l’importation OpenAPI, Gestion des API :
Vérifie spécifiquement les paramètres de chaîne de requête marqués comme
obligatoires.
Par défaut, convertit les paramètres de chaîne de requête requis en paramètres de
modèle requis.
Si vous préférez que les paramètres de requête requis dans la spécification soient
traduits en paramètres de requête dans Gestion des API, désactivez le paramètre Inclure
les paramètres de requête dans les modèles d’opération lors de la création de l’API
dans le portail. Pour ce faire, utilisez les API - Créer ou mettre à jour l’API REST pour
définir la propriété de l’API translateRequiredQueryParameters sur query .
Pour les opérations GET, HEAD et OPTIONS, API Management ignore un paramètre de
corps de requête s’il est défini dans la spécification OpenAPI.
Si vous recevez des erreurs lors de l’importation de votre document OpenAPI, vérifiez
que vous l’avez validée à l’aide de l’une des opérations suivantes :
À l’aide du concepteur du portail Azure (Conception > Front-end > Éditeur de
spécification OpenAPI) ou
Gestion des API lors de l’importation OpenAPI
Limitations relatives à | [
-0.039323028177022934,
0.019590681418776512,
-0.03179394453763962,
-0.043397996574640274,
0.04131028801202774,
0.025981158018112183,
0.029820285737514496,
0.022713864222168922,
-0.03293973580002785,
-0.03579596057534218,
-0.027452316135168076,
-0.0631364956498146,
-0.08663850277662277,
0.0... | {
"azure_component": "network",
"chunk_index": 910,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "678",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
vous recevez des erreurs lors de l’importation de votre document OpenAPI, vérifiez
que vous l’avez validée à l’aide de l’une des opérations suivantes :
À l’aide du concepteur du portail Azure (Conception > Front-end > Éditeur de
spécification OpenAPI) ou
Gestion des API lors de l’importation OpenAPI
Limitations relatives à l’importation
OpenAPI/Swagger | [
-0.03335550054907799,
0.006818566005676985,
-0.0315789096057415,
0.006424484308809042,
0.03238938748836517,
0.018764162436127663,
0.03965453431010246,
0.030388785526156425,
-0.03436322137713432,
-0.017546996474266052,
-0.0070709893479943275,
-0.02035434916615486,
-0.07963947206735611,
-0.0... | {
"azure_component": "network",
"chunk_index": 911,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "678",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Avec un outil tiers, tel que Swagger Editor
.
Condition requise
Description
Noms uniques pour le chemin
d’accès et les paramètres de
requête requis
Dans OpenAPI :
Un nom de paramètre doit être unique seulement dans
un emplacement, par exemple, pour un chemin, une
requête, un en-tête.
Dans Gestion des API :
Nous permettons aux opérations d'être différenciées à la
fois par le chemin d'accès et les paramètres de la
requête.
Étant donné qu’OpenAPI ne prend pas en charge cette
différenciation, les noms de paramètres doivent être
uniques dans l’ensemble du modèle d’URL.
Paramètre d’URL défini
Doit faire partie du modèle d’URL.
URL du fichier source
disponible
Appliquée aux URL de serveur relatives.
\$ref pointeurs
Ne peuvent pas référencer des fichiers externes.
Versions prises en charge
Gestion des API prend en charge uniquement les éléments suivants :
OpenAPI version 2.
OpenAPI version 3.0.x (jusqu’à la version 3.0.3).
OpenAPI version 3.1 (importation uniquement)
Limitations de taille
Généralités
Spécifications de modèle URL
ﾉ
Agrandir le tableau
Spécifications OpenAPI
ﾉ
Agrandir le tableau | [
-0.05580345168709755,
-0.00044016839819960296,
0.005151302088052034,
-0.013976290822029114,
0.04439491033554077,
0.034339699894189835,
0.0038903194945305586,
0.012891286984086037,
-0.028120188042521477,
-0.05331985279917717,
-0.015209322795271873,
-0.03845347464084625,
-0.05108833685517311,
... | {
"azure_component": "network",
"chunk_index": 912,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "679",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Taille maximale
Description
Jusqu’à 4 Mo
Lorsqu’une spécification OpenAPI est importée en ligne dans Gestion
des API.
Taille des requêtes d’API
Azure Resource
Manager
Quand un document OpenAPI est fourni via l’URL d’un emplacement
accessible à partir de votre service Gestion des API. Consultez Limites
des abonnements Azure.
Les seules extensions prises en charge sont :
Extension
Description
x-ms-
paths
Vous permet de définir des chemins qui se différencient par des paramètres
de requête dans l’URL.
Sujets abordés dans les documents AutoRest
.
x-servers
Un rétroportage de l’objet OpenAPI 3 servers
pour OpenAPI 2.
Extension
Description
Recursion
Gestion des API ne prend pas en charge les définitions définies de manière
récursive.
Par exemple, les schémas qui font référence à eux-mêmes.
Server objet
Non pris en charge au niveau des opérations de l’API.
Produces mot
clé
Décrit les types MIME retournés par une API.
Non pris en charge.
Ignorées lors de l’importation.
Non enregistrées ou conservées pour l’exportation.
Extensions prises en charge
ﾉ
Agrandir le tableau
Extensions non prises en charge
ﾉ
Agrandir le tableau
Extensions personnalisées | [
-0.05564909055829048,
-0.02412617765367031,
-0.009349770843982697,
-0.015132593922317028,
0.03533939644694328,
0.005133542697876692,
0.015268458053469658,
0.027293140068650246,
-0.031333617866039276,
-0.039377082139253616,
-0.023734502494335175,
-0.04699268192052841,
-0.07023696601390839,
... | {
"azure_component": "network",
"chunk_index": 913,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "680",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Les définitions de schéma Inline pour les opérations d’API ne sont pas prises en charge.
Définitions de schéma :
Définies dans l’étendue de l’API.
Peuvent être référencées dans les étendues de requête ou de réponse des
opérations de l’API.
Les définitions de sécurité sont ignorées.
Lors de l’importation de paramètres de requête, seule la méthode de sérialisation de
tableau par défaut ( style: form , explode: true ) est prise en charge. Pour plus
d’informations sur les paramètres de requête dans les spécifications OpenAPI, reportez-
vous à la spécification de sérialisation
.
Les paramètres définis dans les cookies
ne sont pas pris en charge. Vous pouvez
toujours utiliser la stratégie pour décoder et valider le contenu des cookies.
La prise en charge d’OpenAPI version 2 est limitée au format JSON uniquement.
Les paramètres de type Form
ne sont pas pris en charge. Vous pouvez utiliser la
stratégie pour décoder et valider et valider les charges utiles application/x-www-form-
urlencoded et application/form-data .
Gestion des API prend en charge les versions de spécification suivantes :
OpenAPI 3.0.3
OpenAPI 3.1.0
(importation uniquement)
Si plusieurs servers sont spécifiés, Gestion des API utilise la première URL HTTPS
trouvée.
Définitions non prises en charge
Définitions ignorées
Restrictions de définition
OpenAPI version 2
OpenAPI version 3.x
URL HTTPS | [
-0.03369280323386192,
0.0014953076606616378,
-0.04237376153469086,
0.0023254910483956337,
0.033391308039426804,
0.03002946823835373,
0.019442934542894363,
0.02045711874961853,
-0.022897712886333466,
-0.03918815404176712,
-0.019172606989741325,
-0.03020504117012024,
-0.06165509670972824,
-0... | {
"azure_component": "network",
"chunk_index": 914,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "681",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
S’il n’y a pas d’URL HTTPS, l’URL du serveur est vide.
example
Les champs suivants sont inclus dans OpenAPI version 3.0.x
ou OpenAPI
version 3.1.x
, mais ne sont pas pris en charge :
Object
Champ
OpenAPI
externalDocs
Info
summary
Composants
responses
parameters
examples
requestBodies
headers
securitySchemes
links
callbacks
PathItem
trace
servers
opération
externalDocs
callbacks
security
servers
Paramètre
allowEmptyValue
style
explode
allowReserved
Prise en charge
Non pris en charge
ﾉ
Agrandir le tableau | [
-0.006944048684090376,
0.006547906901687384,
0.004676686599850655,
0.03486046567559242,
0.012868509627878666,
0.0144750801846385,
0.02157742902636528,
0.022418132051825523,
-0.04218418523669243,
-0.036829352378845215,
-0.03397342562675476,
-0.029555141925811768,
-0.07306922227144241,
0.008... | {
"azure_component": "network",
"chunk_index": 915,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": true,
"service_name": "API Management",
"source": "682",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Les définitions d’API exportées à partir d’un service Gestion des API sont :
Principalement destinées aux applications externes qui doivent appeler l'API
hébergée dans le service Gestion des API.
Non destinées à être importées dans le même service Gestion des API ou dans un
service différent.
Pour la gestion de la configuration des définitions d’API dans différents
services/environnements, consultez la documentation relative à l’utilisation du service
Gestion des API avec Git.
Pour chaque opération trouvée dans le document OpenAPI, une nouvelle opération est
créée avec :
Nom de la ressource Azure définie sur operationId .
La valeur operationId est normalisée.
Si operationId n’est pas spécifié (non présent, null ou vide), la valeur du nom
de la ressource Azure est générée en combinant la méthode HTTP et le modèle
de chemin.
Par exemple : get-foo .
Nom complet défini sur summary .
valeur summary :
Importée telle quelle.
La longueur est limitée à 300 caractères.
Si summary n’est pas spécifié (non présent, null ou vide), la valeur du nom
complet est définie sur operationId .
Règles de normalisation pour operationId
Convertit les caractères en minuscules.
Remplacez chaque séquence de caractères non alphanumériques par un tiret
unique.
Mécanismes d’importation, de mise à jour et
d’exportation OpenAPI
Général
Ajouter une nouvelle API via l’importation OpenAPI | [
-0.057156551629304886,
0.010658690705895424,
-0.01503884419798851,
-0.04970052093267441,
0.04475190117955208,
0.03023616597056389,
0.014762350358068943,
0.05399120971560478,
-0.06870447099208832,
-0.04222770407795906,
-0.025365939363837242,
-0.04526447132229805,
-0.05519887059926987,
0.046... | {
"azure_component": "network",
"chunk_index": 916,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": true,
"service_name": "API Management",
"source": "683",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Par exemple, GET-/foo/{bar}?buzz={quix} est transformé en get-foo-bar-buzz-
quix- .
Coupez les tirets des deux côtés.
Par exemple, get-foo-bar-buzz-quix- devient get-foo-bar-buzz-quix .
Tronquez pour obtenir 76 caractères, quatre caractères de moins que la limite
maximale pour un nom de ressource.
Utilisez les quatre caractères restants pour un suffixe de déduplication, si
nécessaire, sous la forme -1, -2, ..., -999 .
Lors de l’importation, l’opération d’API existante :
Change pour correspondre à l’API décrite dans le document OpenAPI.
Effectue une correspondance sur une opération dans le document OpenAPI en
comparant sa valeur operationId au nom de ressource Azure de l’opération
existante.
Si une correspondance est trouvée, les propriétés de l’opération existante sont
mises à jour « sur place ».
Si aucune correspondance n’est trouvée :
Une nouvelle opération est créée en combinant la méthode HTTP et le
modèle de chemin, par exemple get-foo .
Pour chaque nouvelle opération, l’importation tente de copier les stratégies à
partir d’une opération existante avec la même méthode HTTP et le même
modèle de chemin d’accès.
Toutes les opérations sans correspondance existantes sont supprimées.
Pour que l’importation soit plus prévisible, suivez les instructions ci-dessous :
Spécifiez la propriété operationId pour chaque opération.
Évitez de modifier operationId après l’importation initiale.
Ne modifiez jamais operationId et la méthode HTTP ou le modèle de chemin
d’accès en même temps.
Règles de normalisation pour operationId
Convertit les caractères en minuscules.
Remplacez chaque séquence de caractères non alphanumériques par un tiret
unique.
Par exemple, GET-/foo/{bar}?buzz={quix} est transformé en | [
-0.030044853687286377,
-0.012682514265179634,
-0.018530942499637604,
-0.04458631947636604,
0.06942348182201385,
0.012279808521270752,
0.02001337893307209,
0.07270968705415726,
-0.04070550203323364,
-0.03391650319099426,
-0.05465270206332207,
-0.007479623891413212,
-0.0680311918258667,
0.01... | {
"azure_component": "network",
"chunk_index": 917,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "684",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
après l’importation initiale.
Ne modifiez jamais operationId et la méthode HTTP ou le modèle de chemin
d’accès en même temps.
Règles de normalisation pour operationId
Convertit les caractères en minuscules.
Remplacez chaque séquence de caractères non alphanumériques par un tiret
unique.
Par exemple, GET-/foo/{bar}?buzz={quix} est transformé en get-foo-bar-buzz-
quix- .
Mettre à jour une API existante via l’importation OpenAPI | [
-0.037986449897289276,
-0.0064949351362884045,
-0.010602280497550964,
-0.02915106900036335,
0.07206886261701584,
0.009983986616134644,
0.017880672588944435,
0.03219324350357056,
-0.03372810408473015,
-0.03467593714594841,
-0.014159700833261013,
-0.026072939857840538,
-0.07919184863567352,
... | {
"azure_component": "network",
"chunk_index": 918,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "684",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Coupez les tirets des deux côtés.
Par exemple, get-foo-bar-buzz-quix- devient get-foo-bar-buzz-quix .
Tronquez pour obtenir 76 caractères, quatre caractères de moins que la limite
maximale pour un nom de ressource.
Utilisez les quatre caractères restants pour un suffixe de déduplication, si
nécessaire, sous la forme -1, -2, ..., -999 .
Pour chaque opération :
Le nom de la ressource Azure est exporté en tant que operationId .
Le nom d’affichage est exporté en tant que summary .
Notez que la normalisation de l’opération operationId est effectuée sur l’importation, et
non sur l’exportation.
Vous pouvez créer des API SOAP direct et SOAP à REST avec des fichiers WSDL.
Seules les liaisons SOAP de style d’encodage « document » et « literal » sont prises
en charge.
Les encodages SOAP ou de style « rpc » ne sont pas pris en charge.
Les directives wsdl:import , xsd:import et xsd:include ne sont pas prises en
charge. Au lieu de cela, fusionnez les dépendances au sein d’un même document.
Pour obtenir un outil open source permettant de résoudre et de fusionner les
dépendances wsdl:import , xsd:import et xsd:include dans un fichier WSDL,
consultez ce dépôt GitHub
.
Les fichiers WSDL incorporant des spécifications WS-* ne sont pas pris en charge.
Exporter l’API comme OpenAPI
WSDL
Liaisons SOAP
Importations et inclut
Spécifications WS-* | [
-0.04778297618031502,
-0.01931629702448845,
-0.01733146421611309,
0.012774030677974224,
0.038849879056215286,
0.024424737319350243,
0.0027923351153731346,
0.03379344567656517,
-0.01997733674943447,
-0.05694954842329025,
-0.055051349103450775,
-0.013602914288640022,
-0.05811384320259094,
-0... | {
"azure_component": "network",
"chunk_index": 919,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": true,
"service_name": "API Management",
"source": "685",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Ce type de message n’est pas pris en charge.
Les services SOAP créés avec Windows Communication Foundation doivent utiliser
basicHttpBinding .
wsHttpBinding n’est pas pris en charge.
Les services utilisant MTOM peuvent fonctionner.
Aucune prise en charge officielle n’est disponible pour l’instant.
Les types définis de manière récursive ne sont pas pris en charge par Gestion des
API.
Par exemple, s’ils font référence à un tableau d’eux-mêmes.
Si plusieurs espaces de noms peuvent être utilisés dans un schéma, seul l’espace de
noms cible peut être utilisé pour définir des parties de message. Ces espaces de noms
sont utilisés pour définir d’autres éléments d’entrée ou de sortie.
Les espaces de noms autres que la cible ne sont pas conservés lors de l’exportation. Bien
que vous puissiez importer un document WSDL qui définit des parties de message avec
d’autres espaces de noms, toutes les parties de message disposent de l’espace de noms
cible WSDL lors de l’exportation.
Des fichiers WSDL peuvent définir plusieurs services et points de terminaison (ports) par
un ou plusieurs éléments wsdl:service et wsdl:port . Toutefois, la passerelle Gestion
des API peut importer et proxyser des requêtes vers un unique service et point de
terminaison. Si plusieurs services ou points de terminaison sont définis dans le fichier
WSDL, identifiez le nom et le point de terminaison du service cible lors de l’importation
de l’API au moyen de la propriété wsdlSelector.
Messages avec plusieurs parties
WCF wsHttpBinding
MTOM
Récursivité
Espaces de noms multiples
Points de terminaison multiples | [
-0.06298121064901352,
-0.008499328047037125,
-0.047708820551633835,
0.025265004485845566,
0.0024651812855154276,
0.011695664376020432,
0.040913037955760956,
0.02958082966506481,
-0.024470431730151176,
-0.07014617323875427,
-0.0018824555445462465,
-0.004123250022530556,
-0.06796319037675858,
... | {
"azure_component": "network",
"chunk_index": 920,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "686",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
La transformation SOAP à REST prend uniquement en charge les tableaux encapsulés
indiqués dans l’exemple ci-dessous :
XML
Il n’existe aucun problème connu relatif à l’importation WADL.
Conseil
Si vous souhaitez équilibrer la charge des requêtes entre plusieurs services et
points de terminaison, envisagez de configurer un pool backend à charge
équilibrée.
Tableaux
<complexType name="arrayTypeName">
<sequence>
<element name="arrayElementValue" type="arrayElementType"
minOccurs="0" maxOccurs="unbounded"/>
</sequence>
</complexType>
<complexType name="typeName">
<sequence>
<element name="element1" type="someTypeName" minOccurs="1"
maxOccurs="1"/>
<element name="element2" type="someOtherTypeName" minOccurs="0"
maxOccurs="1" nillable="true"/>
<element name="arrayElement" type="arrayTypeName" minOccurs="1"
maxOccurs="1"/>
</sequence>
</complexType>
WADL | [
-0.04270599037408829,
0.006156017072498798,
-0.059014324098825455,
0.016877014189958572,
0.033844299614429474,
0.0031568175181746483,
-0.022489869967103004,
-0.012302698567509651,
-0.01539643481373787,
-0.036063119769096375,
-0.01760176755487919,
-0.034440550953149796,
-0.04646601900458336,
... | {
"azure_component": "network",
"chunk_index": 921,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "687",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Utiliser Gestion des API Azure avec des
microservices déployés dans Azure
Kubernetes Service
22/06/2025
S’APPLIQUE À : Tous les niveaux de Gestion des API
Les microservices sont idéaux pour la création d’API. Vous pouvez utiliser Azure Kubernetes
Service (AKS)
pour déployer et exploiter rapidement une architecture basée sur des
microservices dans le cloud. Vous pouvez ensuite utiliser Gestion des API Azure
pour publier
vos microservices en tant qu’API pour une consommation interne et externe. Cet article décrit
les options d’utilisation de Gestion des API pour publier des architectures basées sur des
microservices AKS en tant qu’API. Il suppose une connaissance de base de Kubernetes, gestion
des API et mise en réseau Azure.
Lorsque vous publiez des microservices en tant qu’API pour la consommation, il peut être
difficile de gérer la communication entre les microservices et les clients qui les consomment.
Les préoccupations croisées incluent l’authentification, l’autorisation, la limitation, la mise en
cache, la transformation et la surveillance. Ces préoccupations s’appliquent indépendamment
du fait que les microservices soient exposés à des clients internes ou externes.
Le modèle de passerelle API résout ces problèmes. Une passerelle d’API sert de porte d’entrée
aux microservices, dissocie les clients de vos microservices, ajoute une autre couche de sécurité
et réduit la complexité de vos microservices en supprimant le fardeau de la gestion des
préoccupations croisées.
Gestion des API
est une solution clé en main pour répondre aux besoins de votre passerelle
d’API. Vous pouvez créer rapidement une passerelle cohérente et moderne pour vos
microservices et les publier en tant qu’API. En tant que solution de gestion des API de cycle de
vie complet, elle fournit également des fonctionnalités supplémentaires, notamment un portail
de développement libre-service pour la découverte d’API, la gestion du cycle | [
-0.023887140676379204,
-0.01069292426109314,
-0.024633869528770447,
-0.004333288408815861,
0.014840805903077126,
0.05606767162680626,
0.055382490158081055,
0.028716519474983215,
-0.02194882184267044,
-0.029359854757785797,
-0.017872067168354988,
-0.07087721675634384,
-0.05500684306025505,
... | {
"azure_component": "network",
"chunk_index": 922,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "688",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
solution clé en main pour répondre aux besoins de votre passerelle
d’API. Vous pouvez créer rapidement une passerelle cohérente et moderne pour vos
microservices et les publier en tant qu’API. En tant que solution de gestion des API de cycle de
vie complet, elle fournit également des fonctionnalités supplémentaires, notamment un portail
de développement libre-service pour la découverte d’API, la gestion du cycle de vie des API et
l’analytique des API.
En cas d’utilisation conjointe, AKS et Gestion des API offrent une plateforme pour le
déploiement, la publication, la sécurisation, la surveillance et la gestion de vos API basées sur
des microservices. Cet article décrit quelques options pour déployer AKS conjointement avec
Gestion des API.
Arrière-plan | [
0.0002646624925546348,
-0.003111589001491666,
-0.008574126288294792,
-0.014994668774306774,
0.036830559372901917,
0.03125184401869774,
0.027105960994958878,
0.03303501754999161,
-0.07354682683944702,
-0.034696634858846664,
0.0011878221994265914,
-0.0409918874502182,
-0.05705979838967323,
0... | {
"azure_component": "network",
"chunk_index": 923,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "688",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Dans un cluster Kubernetes, les conteneurs sont déployés dans des pods
, qui sont
éphémères et ont un cycle de vie. En cas d’échec d’un nœud Worker, les pods s’exécutant sur
le nœud sont perdus. Par conséquent, l’adresse IP d’un pod peut changer à tout moment. Vous
ne pouvez pas vous en fier pour communiquer avec le pod.
Pour résoudre ce problème, Kubernetes a introduit le concept de services
. Un service
Kubernetes est une couche d’abstraction qui définit un groupe logique de pods et active
l’exposition du trafic externe, l’équilibrage de charge et la découverte de service pour ces pods.
Lorsque vous êtes prêt à publier vos microservices en tant qu’API à l’aide de Gestion des API,
vous devez réfléchir à la façon de mapper vos services dans Kubernetes aux API dans Gestion
des API. Il n’existe aucune règle définie pour ce mappage. Cela dépend de la façon dont vous
avez conçu et partitionné vos capacités ou domaines métier en microservices au début. Par
exemple, si les pods derrière un service sont responsables de toutes les opérations sur une
ressource donnée (par exemple, Client), vous pouvez mapper le service à une API. Si des
opérations sur une ressource sont partitionnées en plusieurs microservices (par exemple,
GetOrder et PlaceOrder), vous pouvez agréger plusieurs services en une seule API dans Gestion
des API. (Consultez le diagramme suivant.)
Les mappages peuvent également évoluer. Étant donné que Gestion des API crée une façade
devant les microservices, elle vous permet de refactoriser et de dimensionner correctement vos
microservices au fil du temps.
Services Kubernetes et API
Déployer Gestion des API devant AKS | [
-0.013925252482295036,
-0.03739774227142334,
-0.0214221253991127,
0.0013372462708503008,
0.0304426159709692,
0.04089643061161041,
0.015201971866190434,
0.040481410920619965,
-0.06705042719841003,
-0.055778782814741135,
-0.011295365169644356,
-0.05490310490131378,
-0.04117649793624878,
0.06... | {
"azure_component": "network",
"chunk_index": 924,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "689",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Il existe quelques options pour déployer gestion des API devant un cluster AKS.
Un cluster AKS est toujours déployé dans un réseau virtuel, mais une instance gestion des API
n’est pas nécessairement déployée dans un réseau virtuel. Lorsque Gestion des API ne réside
pas dans le réseau virtuel du cluster, le cluster AKS doit publier des points de terminaison
publics pour que Gestion des API se connecte. Dans ce cas, vous devez sécuriser la connexion
entre Gestion des API et AKS. En d’autres termes, vous devez vous assurer que le cluster est
accessible uniquement via Gestion des API. Les sections suivantes décrivent les options de
déploiement de gestion des API devant AKS.
Vous pouvez exposer publiquement les services dans un cluster AKS à l’aide des types de
service NodePort, LoadBalancer ou ExternalName. Lorsque vous le faites, les services sont
accessibles directement à partir de l’Internet public. Après avoir déployé gestion des API
devant le cluster, vous devez vous assurer que tout le trafic entrant passe par Gestion des API
en appliquant l’authentification dans les microservices. Par exemple, Gestion des API peut
inclure un jeton d’accès dans chaque demande envoyée au cluster. Chaque microservice doit
valider le jeton avant de traiter la demande.
Cette option peut fournir le moyen le plus simple de déployer gestion des API devant AKS, en
particulier si vous avez déjà une logique d’authentification implémentée dans vos
microservices.
Avantages :
Option 1 : exposer les services publiquement
| [
-0.05295183137059212,
0.016735125333070755,
-0.028105948120355606,
0.009771543554961681,
0.004805515520274639,
0.044989317655563354,
0.049553632736206055,
0.028154151514172554,
-0.06125457212328911,
-0.018445098772644997,
-0.04110635817050934,
-0.060101550072431564,
-0.030518123880028725,
... | {
"azure_component": "network",
"chunk_index": 925,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "690",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Configuration simple côté Gestion des API, car la gestion des API n’a pas besoin d’être
injectée dans le réseau virtuel de cluster
Aucune modification du côté AKS si les services sont déjà exposés publiquement et si la
logique d’authentification existe déjà dans les microservices
Inconvénients :
Crée un risque de sécurité potentiel en raison de la visibilité publique des points de
terminaison
Ne crée pas de point d’entrée unique pour le trafic de cluster entrant
Complique les microservices avec une logique d’authentification dupliquée
Bien que l’option 1 soit plus facile, elle présente des inconvénients notables, comme indiqué
précédemment. Si une instance gestion des API ne réside pas dans le réseau virtuel du cluster,
l’authentification TLS mutuelle (mTLS) est un moyen robuste de s’assurer que le trafic est
sécurisé et approuvé dans les deux sens entre une instance gestion des API et un cluster AKS.
L’authentification TLS mutuelle est prise en charge en mode natif par Gestion des API. Vous
pouvez l’activer dans Kubernetes en installant un contrôleur d’entrée. (Consultez le diagramme
suivant.) Par conséquent, l’authentification est effectuée dans le contrôleur d’entrée, ce qui
simplifie les microservices. En outre, dans les niveaux de service qui prennent en charge les
adresses IP dédiées, vous pouvez ajouter les adresses IP de Gestion des API à la liste verte
d’entrée pour vous assurer que seule gestion des API a accès au cluster.
Avantages :
Option 2 : Installer un contrôleur d’entrée
| [
-0.033382002264261246,
0.018611863255500793,
-0.014328966848552227,
0.003937302622944117,
0.029239267110824585,
0.04179190844297409,
0.04366210103034973,
0.012237615883350372,
-0.06310980021953583,
-0.019096096977591515,
-0.009910807944834232,
-0.046221744269132614,
-0.045213934034109116,
... | {
"azure_component": "network",
"chunk_index": 926,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "691",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Permet une configuration facile côté Gestion des API, car la gestion des API n’a pas
besoin d’être injectée dans le réseau virtuel de cluster et mTLS est prise en charge en
mode natif
Centralise la protection du trafic de cluster entrant au niveau de la couche contrôleur
d’entrée
Réduit les risques de sécurité en réduisant au minimum les points de terminaison de
cluster visibles publiquement
Inconvénients :
Augmente la complexité de la configuration du cluster, car vous devez installer,
configurer et gérer le contrôleur d’entrée et gérer les certificats utilisés pour mTLS
Ajoute un risque de sécurité en raison de la visibilité publique des points de terminaison
du contrôleur d’entrée, sauf si vous utilisez le niveau Gestion des API Standard v2 ou
Premium
Lorsque vous publiez des API via Gestion des API, il est facile et courant de sécuriser l’accès à
ces API à l’aide de clés d’abonnement. Les développeurs qui utilisent les API publiées doivent
inclure une clé d’abonnement valide dans les requêtes HTTP lorsqu’ils effectuent des appels
vers ces API. Sinon, les appels sont immédiatement rejetés par la passerelle de Gestion des API.
Ils ne sont pas transférés aux services principaux.
Pour obtenir une clé d’abonnement pour accéder aux API, les développeurs ont besoin d’un
abonnement. Un abonnement est avant tout un conteneur nommé pour une paire de clés
d’abonnement. Les développeurs devant utiliser les API publiées peuvent obtenir des
abonnements. Ils n’ont pas besoin d’approbation auprès des éditeurs d’API. Les éditeurs d’API
peuvent également créer des abonnements directement pour les consommateurs d’API.
Dans certains cas, les clients qui ont des contraintes réglementaires ou des exigences de
sécurité strictes peuvent trouver les options | [
-0.015549864619970322,
0.004666303750127554,
-0.006343463435769081,
-0.014458606019616127,
0.03919419273734093,
0.01293200347572565,
0.019700344651937485,
0.029834812507033348,
-0.05051969364285469,
-0.03241937980055809,
-0.026393890380859375,
-0.03447386622428894,
-0.048940662294626236,
0... | {
"azure_component": "network",
"chunk_index": 927,
"contains_sku": true,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "692",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
API publiées peuvent obtenir des
abonnements. Ils n’ont pas besoin d’approbation auprès des éditeurs d’API. Les éditeurs d’API
peuvent également créer des abonnements directement pour les consommateurs d’API.
Dans certains cas, les clients qui ont des contraintes réglementaires ou des exigences de
sécurité strictes peuvent trouver les options 1 et 2 non utilisables en raison des points de
terminaison exposés publiquement. Dans d’autres, le cluster AKS et les applications qui
consomment les microservices peuvent résider dans le même réseau virtuel. Il n’y a donc
aucune raison d’exposer le cluster publiquement, car tout le trafic d’API reste dans le réseau
virtuel. Dans ces scénarios, vous pouvez déployer Gestion des API dans le réseau virtuel de
cluster. Les niveaux Développeur Gestion des API, Premium et Premium v2 (préversion)
prennent en charge l’injection dans le réseau virtuel de cluster.
Il existe deux modes de déploiement de Gestion des API dans un réseau virtuel : externe et
interne. Actuellement, le mode externe n’est disponible que dans les niveaux classiques de
Option 3 : Déployer gestion des API à l’intérieur du réseau
virtuel de cluster | [
-0.005976539105176926,
-0.0011008429573848844,
0.008382478728890419,
0.0008765559759922326,
0.011883262544870377,
0.047108184546232224,
0.0426209457218647,
0.00838424637913704,
-0.08037295937538147,
-0.03040892444550991,
-0.0453777089715004,
-0.016007158905267715,
-0.05693504586815834,
0.0... | {
"azure_component": "network",
"chunk_index": 928,
"contains_sku": true,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "692",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Gestion des API.
Si les consommateurs d’API ne résident pas dans le réseau virtuel de cluster, vous devez utiliser
le mode externe. (Consultez le diagramme suivant.) Dans ce mode, la passerelle Gestion des
API est injectée dans le réseau virtuel du cluster, mais accessible à partir de l’Internet public via
un équilibreur de charge externe. Cette architecture permet de masquer complètement le
cluster tout en permettant aux clients externes de consommer les microservices. En outre, vous
pouvez utiliser des fonctionnalités de mise en réseau Azure telles que des groupes de sécurité
réseau (NSG) pour restreindre le trafic réseau.
Si tous les consommateurs d’API résident dans le réseau virtuel du cluster, vous pouvez utiliser
le mode interne. (Consultez le diagramme suivant.) Dans ce mode, la passerelle Gestion des API
est injectée dans le réseau virtuel du cluster et accessible uniquement à partir de ce réseau
virtuel via un équilibreur de charge interne. Il n’existe aucun moyen d’atteindre la passerelle
Gestion des API ou le cluster AKS à partir de l’Internet public.
| [
-0.015860600396990776,
-0.02779838815331459,
0.012963058426976204,
-0.029435670003294945,
0.03330915421247482,
0.013637981377542019,
0.029327809810638428,
0.02716228738427162,
-0.06663937866687775,
-0.029599439352750778,
-0.03316756337881088,
-0.04565417021512985,
-0.040993258357048035,
0.... | {
"azure_component": "network",
"chunk_index": 929,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "693",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Le cluster AKS n’est pas visible publiquement dans les deux cas. Contrairement à l’option 2, le
contrôleur d’entrée peut ne pas être nécessaire. Selon votre scénario et votre configuration,
l’authentification peut toujours être nécessaire entre Gestion des API et vos microservices. Par
exemple, si vous utilisez un maillage de services, vous avez toujours besoin d’une
authentification TLS mutuelle.
Avantages :
Fournit l’option la plus sécurisée, car le cluster AKS n’a pas de point de terminaison public
Simplifie la configuration du cluster, car il n’existe aucun point de terminaison public
Permet de masquer la gestion des API et AKS à l’intérieur du réseau virtuel à l’aide du
mode interne
Offre la possibilité de contrôler le trafic réseau à l’aide de fonctionnalités de mise en
réseau Azure telles que le groupe de sécurité réseau
Inconvénients :
Augmente la complexité du déploiement et de la configuration de gestion des API pour
travailler à l’intérieur du réseau virtuel
Contenu connexe | [
-0.06637044996023178,
0.01572052389383316,
-0.045360859483480453,
0.007630418986082077,
0.028485655784606934,
0.027717679738998413,
0.046728525310754776,
0.017184091731905937,
-0.0184644665569067,
-0.03556179255247116,
-0.042050037533044815,
-0.06440847367048264,
-0.042099595069885254,
0.0... | {
"azure_component": "network",
"chunk_index": 930,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "694",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Concepts réseau pour les applications dans AKS
Comment utiliser Gestion des API avec des réseaux virtuels | [
-0.006139291450381279,
0.018963705748319626,
-0.0006491952808573842,
-0.011289006099104881,
0.0043691108003258705,
0.04527035355567932,
0.021962430328130722,
0.0399707555770874,
-0.06898020952939987,
-0.031869299709796906,
-0.03456832841038704,
-0.007880233228206635,
-0.08505804091691971,
... | {
"azure_component": "network",
"chunk_index": 931,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "695",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Vue d’ensemble d’Azure Service Fabric
avec Gestion des API
Article • 15/10/2024
Les applications cloud ont généralement besoin d’une passerelle frontale afin de fournir
un point d’entrée unique pour les utilisateurs, les appareils ou d’autres applications.
Dans Service Fabric, une passerelle peut être n’importe quel service sans état, comme
une application ASP.NET Core, ou un autre service conçu pour l’entrée de trafic, par
exemple les concentrateurs d’événements, IoT Hub ou Gestion des API Azure.
Cet article présente l’utilisation de Gestion des API Azure en tant que passerelle vers vos
applications Service Fabric. Gestion des API s’intègre directement dans Service Fabric, ce
qui vous permet de publier des API avec un ensemble complet de règles de routage
vers vos services Service Fabric principaux.
Une architecture Service Fabric commune utilise une application web d’une seule page
qui effectue des appels HTTP vers les services principaux exposant les API HTTP.
L’exemple d’application Service Fabric de mise en route
montre un exemple de cette
architecture.
Dans ce scénario, un service web sans état sert de passerelle vers l’application Service
Fabric. Cette approche nécessite que vous écriviez un service web capable de
transmettre les requêtes HTTP aux services principaux, comme indiqué dans le
diagramme suivant :
Disponibilité
） Important
Cette fonctionnalité est disponible aux niveaux Premium et Développeur de
Gestion des API en raison de la prise en charge de réseau virtuel requise.
Architecture | [
0.0006717954529449344,
-0.028804467990994453,
-0.006702649872750044,
-0.014782066456973553,
0.03837629035115242,
0.05292150005698204,
0.02236918732523918,
0.047533273696899414,
-0.03826940804719925,
-0.08973389118909836,
-0.04079313576221466,
-0.08196540921926498,
-0.046672046184539795,
0.... | {
"azure_component": "network",
"chunk_index": 932,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "696",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Les applications sont de plus en plus complexes et il en va de même pour les passerelles
qui doivent présenter une API devant une multitude de services principaux. Gestion des
API Azure est conçue pour gérer les API complexes avec des règles de routage, un
contrôle d’accès, une limitation du débit, une surveillance, une journalisation des
événements et une mise en cache des réponses, mais impliquant un minimum de travail
de votre part. Gestion des API Azure prend en charge la détection du service Service
Fabric, la résolution de partition et la sélection de réplica pour acheminer les requêtes
intelligemment et directement vers des services principaux dans Service Fabric, ce qui
vous évite d’avoir à écrire votre propre passerelle API sans état.
Dans ce scénario, l’IU web est toujours prise en charge par un service web, tandis que
les appels API HTTP sont gérés et acheminés par le biais de Gestion des API Azure,
comme indiqué dans le diagramme suivant : | [
0.0029256539419293404,
0.007289886940270662,
-0.01646166853606701,
0.008557983674108982,
0.02005494013428688,
0.029033225029706955,
0.021121777594089508,
0.04014040157198906,
-0.04948664829134941,
-0.04180361330509186,
-0.010583734139800072,
-0.06276873499155045,
-0.04014674946665764,
0.03... | {
"azure_component": "network",
"chunk_index": 933,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "697",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Les services de Service Fabric peuvent être sans état ou avec état, et ils peuvent être
partitionnés selon l’un des trois modèles : singleton, plage Int64, et nommé. La
résolution du point de terminaison de service requiert l’identification d’une partition
spécifique d’une instance de service spécifique. Lors de la résolution d’un point de
terminaison de service, le nom d’instance de service (par exemple,
fabric:/myapp/myservice ) ainsi que la partition spécifique du service doivent être
indiqués, sauf dans le cas d’une partition singleton.
Gestion des API Azure peut être utilisée avec n’importe quelle combinaison de services
sans état, services avec état et schéma de partition.
Dans le cas le plus simple, le trafic est transféré à une instance de service sans état. Pour
ce faire, une opération Gestion des API contient une stratégie de traitement entrant avec
un service principal Service Fabric qui effectue un mappage à une instance de service
sans état spécifique dans le service principal Service Fabric. Les requêtes envoyées à ce
service le sont à une instance aléatoire du service.
Exemple
Dans le scénario suivant, une application Service Fabric contient un service sans état
nommé fabric:/app/fooservice qui expose une API HTTP interne. Le nom d’instance de
Scénarios d’application
Envoyer le trafic vers un service sans état | [
-0.037785205990076065,
-0.06108378991484642,
-0.027903828769922256,
-0.007372381631284952,
0.041868340224027634,
0.0933748334646225,
0.013150203041732311,
0.03299257531762123,
-0.06560497730970383,
-0.06406527012586594,
-0.024321995675563812,
-0.11044652760028839,
-0.016160640865564346,
0.... | {
"azure_component": "network",
"chunk_index": 934,
"contains_sku": true,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "698",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
service est bien connu et peut être codé en dur directement dans la stratégie de
traitement entrant Gestion des API.
Comme pour le scénario de service sans état, le trafic peut être transféré à une instance
de service avec état. Dans ce cas, une opération Gestion des API contient une stratégie
de traitement entrant avec un service principal Service Fabric qui mappe une requête à
une partition d’instance de service avec état spécifique. La partition à laquelle mapper
chaque requête est calculée par le biais d’une méthode lambda qui utilise une entrée à
partir de la requête HTTP entrante, comme une valeur dans le chemin d’accès d’URL. La
stratégie peut être configurée de manière à envoyer des requêtes pour le réplica
principal uniquement, ou à un réplica aléatoire pour les opérations de lecture.
Exemple
Dans le scénario suivant, une application Service Fabric contient un service partitionné
avec état, nommé fabric:/app/userservice , qui expose une API HTTP interne. Le nom
d’instance de service est bien connu et peut être codé en dur directement dans la
stratégie de traitement entrant Gestion des API.
Le service est partitionné à l’aide du schéma de partition Int64, avec deux partitions et
une plage de clés qui s’étend de Int64.MinValue à Int64.MaxValue . La stratégie de
serveur principal calcule une clé de partition dans cette plage en convertissant la valeur
id fournie dans le chemin d’accès de requête URL à un entier 64 bits, bien que
n’importe quel algorithme puisse être utilisé ici pour calculer la clé de partition.
Envoyer le trafic vers un service avec état | [
-0.011036957614123821,
-0.05653582513332367,
-0.021766316145658493,
-0.02673993445932865,
0.030303744599223137,
0.061360351741313934,
0.029984433203935623,
0.044826436787843704,
-0.06601152569055557,
-0.07188461720943451,
-0.04751366749405861,
-0.09383320063352585,
-0.034678470343351364,
0... | {
"azure_component": "network",
"chunk_index": 935,
"contains_sku": true,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "699",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Dans des scénarios plus avancés, vous pouvez définir une opération Gestion des API qui
mappe les requêtes à plusieurs instances de service. Dans ce cas, chaque opération
contient une stratégie qui mappe les requêtes à une instance de service spécifique en
fonction des valeurs définies à partir de la requête HTTP entrante, comme le chemin
d’accès URL ou la chaîne de requête, et pour les services avec état, une partition dans
l’instance de service.
Pour ce faire, une opération Gestion des API contient une stratégie de traitement
entrant avec un service principal Service Fabric qui effectue un mappage à une instance
de service sans état dans le service principal Service Fabric basé sur les valeurs
récupérées dans la requête HTTP entrante. Les requêtes envoyées à un service le sont à
une instance aléatoire du service.
Exemple
Dans cet exemple, une instance de service sans état est créée pour chaque utilisateur
d’une application avec un nom généré de manière dynamique à l’aide de la formule
suivante :
fabric:/app/users/<username>
Chaque service a un nom unique, mais ces noms ne sont pas connus au départ, car
les services sont créés en réponse à une entrée utilisateur ou administrateur et ils
ne peuvent donc pas être codés en dur dans des stratégies APIM ou des règles de
routage. Au lieu de cela, le nom du service auquel vous souhaitez envoyer une
requête est généré dans la définition de stratégie principale à partir de la valeur
name fournie dans le chemin d’accès de requête URL. Par exemple :
Envoyer le trafic vers plusieurs services sans
état | [
-0.024438802152872086,
-0.05160166323184967,
-0.010903637856245041,
-0.03682528808712959,
0.02471034787595272,
0.055680353194475174,
0.02551179565489292,
0.05008430778980255,
-0.07959438115358353,
-0.06621294468641281,
-0.05994800105690956,
-0.07661164551973343,
-0.033363211899995804,
0.02... | {
"azure_component": "network",
"chunk_index": 936,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "700",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Une requête vers /api/users/foo est acheminée vers l’instance de service
fabric:/app/users/foo
Une requête vers /api/users/bar est acheminée vers l’instance de service
fabric:/app/users/bar
Tout comme l’exemple de service sans état, une opération Gestion des API peut mapper
les requêtes à plusieurs instances de service avec état. Dans ce cas, vous aurez peut-être
aussi besoin d’effectuer la résolution de partition pour chaque instance de service avec
état.
Pour ce faire, une opération Gestion des API contient une stratégie de traitement
entrant avec un service principal Service Fabric qui effectue un mappage à une instance
de service avec état dans le service principal Service Fabric basé sur les valeurs
récupérées dans la requête HTTP entrante. En plus de mapper une requête à une
instance de service spécifique, la requête peut être mappée à une partition spécifique au
sein de l’instance de service, et éventuellement au réplica principal ou à un réplica
secondaire aléatoire au sein de la partition.
Exemple
Envoyer le trafic vers plusieurs services avec
état | [
-0.018938733264803886,
-0.06353545188903809,
-0.013750779442489147,
-0.03527361899614334,
0.047035522758960724,
0.061941761523485184,
0.032854706048965454,
0.02651253342628479,
-0.06660076975822449,
-0.05511784926056862,
-0.045700520277023315,
-0.07498856633901596,
-0.05292297527194023,
0.... | {
"azure_component": "network",
"chunk_index": 937,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "701",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Dans cet exemple, une instance de service avec état est créée pour chaque utilisateur de
l’application avec un nom généré de manière dynamique à l’aide de la formule suivante :
fabric:/app/users/<username>
Chaque service a un nom unique, mais ces noms ne sont pas connus au départ, car
les services sont créés en réponse à une entrée utilisateur ou administrateur et ils
ne peuvent donc pas être codés en dur dans des stratégies APIM ou des règles de
routage. Au lieu de cela, le nom du service auquel vous souhaitez envoyer une
requête est généré dans la définition de stratégie principale à partir de la valeur
name fournie dans le chemin d’accès de requête URL. Par exemple :
Une requête vers /api/users/foo est acheminée vers l’instance de service
fabric:/app/users/foo
Une requête vers /api/users/bar est acheminée vers l’instance de service
fabric:/app/users/bar
Chaque instance de service est également partitionnée à l’aide du schéma de partition
Int64, avec deux partitions et une plage de clés qui s’étend de Int64.MinValue à
Int64.MaxValue . La stratégie de serveur principal calcule une clé de partition dans cette
plage en convertissant la valeur id fournie dans le chemin d’accès de requête URL à un
entier 64 bits, bien que n’importe quel algorithme puisse être utilisé ici pour calculer la
clé de partition. | [
-0.028731748461723328,
-0.03934478387236595,
-0.021102985367178917,
-0.020456572994589806,
0.040602777153253555,
0.08478677272796631,
0.010441847145557404,
0.026968372985720634,
-0.06609112024307251,
-0.055667694658041,
-0.04580766335129738,
-0.06998712569475174,
-0.061584945768117905,
0.0... | {
"azure_component": "network",
"chunk_index": 938,
"contains_sku": true,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "702",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Commentaires
Cette page a-t-elle été utile ?
Indiquer des commentaires sur le produit
| Obtenir de l’aide sur Microsoft Q&A
Suivez le didacticiel pour configurer votre premier cluster Service Fabric avec Gestion
des API et faire passer les requêtes par le biais de Gestion des API vers vos services.
Étapes suivantes
Yes
No | [
0.02790699154138565,
-0.01830395869910717,
0.020527565851807594,
0.006316152401268482,
0.048211462795734406,
0.057712554931640625,
0.01284738164395094,
0.04875965043902397,
-0.039317596703767776,
-0.04699190706014633,
-0.03590812161564827,
-0.02222009375691414,
-0.048815540969371796,
0.024... | {
"azure_component": "network",
"chunk_index": 939,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "703",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Modifier une API
05/06/2025
S’APPLIQUE À : Tous les niveaux de Gestion des API
Les étapes de ce didacticiel vous montrent comment utiliser le service Gestion des API pour
modifier une API.
Vous pouvez ajouter, renommer ou supprimer des opérations dans le portail Azure.
Vous pouvez modifier le Swagger de votre API.
Créer une instance du service Gestion des API Azure
Importer et publier votre première API
1. Dans le portail
Azure, recherchez et sélectionnez Services de gestion des API :
2. Sur la page des services de gestion des API, sélectionnez votre instance de gestion des
API :
Prérequis
Accéder à votre instance Gestion des API
| [
0.007073310203850269,
0.0038746001664549112,
0.0034541019704192877,
-0.007290364243090153,
0.024301210418343544,
0.0445144921541214,
0.03190571814775467,
0.034494832158088684,
-0.07772718369960785,
-0.050539590418338776,
-0.03479330241680145,
-0.04833443462848663,
-0.048193059861660004,
0.... | {
"azure_component": "network",
"chunk_index": 940,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "704",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
1. Cliquez sur l’onglet API.
2. Sélectionnez l’une des API que vous avez importées précédemment.
3. Sélectionnez l’onglet Conception.
4. Sélectionnez une opération à modifier.
5. Pour renommer l’opération, sélectionnez un crayon dans la fenêtre FrontEnd.
Vous pouvez mettre à jour votre API de service de serveur principal à partir du portail Azure en
suivant ces étapes :
1. Sélectionnez Toutes les opérations.
2. Cliquez sur le crayon dans la fenêtre FrontEnd.
Modifier une opération
Mettre à jour le Swagger | [
0.003927659709006548,
-0.03628762811422348,
0.019197847694158554,
-0.01381416991353035,
0.03216227889060974,
0.050488296896219254,
-0.017641162499785423,
0.057453982532024384,
-0.05861910432577133,
-0.07645507156848907,
-0.0478707030415535,
-0.0072781904600560665,
-0.0612691193819046,
-0.0... | {
"azure_component": "network",
"chunk_index": 941,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "705",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Le Swagger de votre API s’affiche.
3. Mettez à jour le Swagger.
4. Appuyez sur Enregistrer.
Ｕ Attention
Si vous modifiez une révision non actuelle d’une API, vous ne pouvez pas changer les
propriétés suivantes :
Nom
Catégorie
Descriptif | [
-0.002059524180367589,
-0.03537172079086304,
0.008327568881213665,
0.010961230844259262,
0.017653673887252808,
0.05116990581154823,
0.03707417845726013,
0.008057339116930962,
-0.06832382827997208,
-0.03842048719525337,
-0.023698782548308372,
-0.008106094785034657,
-0.05392248183488846,
0.0... | {
"azure_component": "network",
"chunk_index": 942,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "706",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Limitations de l’importation d’API
Importer une spécification OpenAPI
Importer une API SOAP
Importer une API SOAP et la convertir en REST
Importer une API App Service
Importer une API d’application conteneur
Importer une API WebSocket
Importer une API GraphQL
Importer un schéma GraphQL et configurer des résolveurs de champs
Importer une API d’application de fonction
Importer une API d’application logique
Importer un service Service Fabric
Importer une API Azure AI Foundry
Importer une API Azure OpenAI
Importer une API LLM
Importer une API OData
Importer des métadonnées OData de SAP
Importer une API gRPC
Modifier une API
Abonnement obligatoire
Version de l'API
Description de la version de l’API
Chemin
Protocoles
Si vos modifications changent l’une des propriétés ci-dessus d’une révision non actuelle, le
message d’erreur Can't change property for non-current revision s’affiche.
Contenu connexe | [
-0.047519657760858536,
-0.022637933492660522,
-0.04089004173874855,
-0.010680084116756916,
0.03859931230545044,
0.03251966834068298,
0.03901675343513489,
0.04347066208720207,
-0.021794086322188377,
-0.05637374892830849,
-0.00861161109060049,
-0.04811953008174896,
-0.09213383495807648,
0.02... | {
"azure_component": "network",
"chunk_index": 943,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "707",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Versions dans Gestion des API Azure
06/06/2025
S’APPLIQUE À : tous les niveaux de Gestion des API
Les versions vous permettent de présenter des groupes d’API associées à vos développeurs.
Vous pouvez utiliser des versions pour traiter en toute sécurité les changements cassants dans
votre API. Les clients peuvent choisir d’utiliser la nouvelle version de votre API lorsqu’ils sont
prêts, tandis que les clients existants continuent d’utiliser une version antérieure. Les versions
sont différenciées via un identificateur de version (qui est n’importe quelle valeur de chaîne
que vous choisissez), et un schéma de contrôle de version permet aux clients d’identifier la
version d’une API qu’ils souhaitent utiliser. Cet article explique comment utiliser des versions
dans Gestion des API.
Dans la plupart des cas, chaque version d’API peut être considérée comme sa propre API
indépendante. Deux versions d’API distinctes peuvent avoir différents ensembles d’opérations
et des stratégies spécifiques.
Avec les versions, vous pouvez :
Publiez simultanément plusieurs versions de votre API.
Utilisez un chemin d’accès, une chaîne de requête ou un en-tête pour différencier les
versions.
Utilisez n’importe quelle valeur de chaîne pour identifier votre version. Il peut s’agir d’un
nombre, d’une date ou d’un nom.
Affichez vos versions d’API regroupées sur le portail des développeurs.
Créez une nouvelle version d’une API existante (non versionnée) sans affecter les clients
existants.
Prise en main des versions en effectuant une procédure pas à pas.
Différents développeurs d’API ont des exigences différentes pour le contrôle de version.
Gestion des API Azure ne prescrit pas une approche unique du contrôle de version, mais
fournit plutôt plusieurs options.
Lorsque le schéma de contrôle de version du chemin d’accès est utilisé, l’identificateur | [
-0.014377635903656483,
0.008827608078718185,
0.011208100244402885,
-0.03261159732937813,
0.04038260877132416,
0.02711368538439274,
0.04584109038114548,
0.023763656616210938,
-0.06510833650827408,
-0.056614115834236145,
-0.021767575293779373,
-0.04610641300678253,
-0.0891866683959961,
0.031... | {
"azure_component": "network",
"chunk_index": 944,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "708",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
en main des versions en effectuant une procédure pas à pas.
Différents développeurs d’API ont des exigences différentes pour le contrôle de version.
Gestion des API Azure ne prescrit pas une approche unique du contrôle de version, mais
fournit plutôt plusieurs options.
Lorsque le schéma de contrôle de version du chemin d’accès est utilisé, l’identificateur de
version doit être inclus dans le chemin d’URL pour toutes les demandes d’API.
Schémas de contrôle de version
Contrôle de version basé sur le chemin d’accès | [
-0.03084639087319374,
0.030339928343892097,
-0.024717146530747414,
0.004193715751171112,
0.08310402184724808,
-0.0003590582055039704,
0.02480950951576233,
0.018327146768569946,
-0.03246878832578659,
-0.05994272977113724,
-0.020135296508669853,
-0.031143853440880775,
-0.08063998818397522,
0... | {
"azure_component": "network",
"chunk_index": 945,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "708",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Par exemple, https://apis.contoso.com/products/v1 et https://apis.contoso.com/products/v2
peut faire référence à la même products API, mais aux versions v1 et v2 .
Le format d’une URL de requête d’API lorsque vous utilisez le contrôle de version basé sur le
chemin est https://{yourDomain}/{apiName}/{versionIdentifier}/{operationId} .
Lorsque le schéma de contrôle de version d’en-tête est utilisé, l’identificateur de version doit
être inclus dans un en-tête de requête HTTP pour toutes les demandes d’API. Vous pouvez
spécifier le nom de l’en-tête de requête HTTP.
Par exemple, vous pouvez créer un en-tête personnalisé nommé Api-Version , et les clients
peuvent spécifier v1 ou v2 dans la valeur de cet en-tête.
Lorsque le schéma de contrôle de version de chaîne de requête est utilisé, l’identificateur de
version doit être inclus dans un paramètre de chaîne de requête pour toutes les demandes
d’API. Vous pouvez spécifier le nom du paramètre de chaîne de requête.
Le format d’une URL de requête d’API lorsque vous utilisez le contrôle de version basé sur des
chaînes de requête est https://{yourDomain}/{apiName}/{operationId}?
{queryStringParameterName}={versionIdentifier} .
Par exemple, https://apis.contoso.com/products?api-version=v1 et
https://apis.contoso.com/products?api-version=v2 peut faire référence à la même products
API, mais aux versions v1 et v2 .
Si vous ajoutez une version à une API non versionnée, une Original version est
automatiquement créée et répond sur l’URL par défaut, sans identificateur de version spécifié.
La Original version garantit que tous les appelants existants ne sont pas affectés par le
Versionnage basé sur l’en-tête
Contrôle de version basé sur une chaîne de requête
７ Notes
Les paramètres de requête ne sont | [
-0.00576395820826292,
0.00437565753236413,
0.000581682485062629,
-0.02069481648504734,
0.06714118272066116,
0.03220502659678459,
0.007575443014502525,
0.03426264226436615,
-0.029194824397563934,
-0.032464947551488876,
0.005594207439571619,
-0.03265560790896416,
-0.08235161751508713,
0.0409... | {
"azure_component": "network",
"chunk_index": 946,
"contains_sku": true,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "709",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
version à une API non versionnée, une Original version est
automatiquement créée et répond sur l’URL par défaut, sans identificateur de version spécifié.
La Original version garantit que tous les appelants existants ne sont pas affectés par le
Versionnage basé sur l’en-tête
Contrôle de version basé sur une chaîne de requête
７ Notes
Les paramètres de requête ne sont pas autorisés dans la servers propriété d’une
spécification OpenAPI. Si vous exportez une spécification OpenAPI à partir d’une version
d’API, une chaîne de requête n’apparaît pas dans l’URL du serveur.
Versions d’origine | [
-0.027109334245324135,
-0.001368823228403926,
0.00255016447044909,
-0.02812158688902855,
0.06203602999448776,
0.04072750732302666,
0.03390689939260483,
0.009772033430635929,
-0.05244928598403931,
-0.05625458434224129,
-0.022763270884752274,
-0.03317216783761978,
-0.10512325912714005,
0.037... | {
"azure_component": "network",
"chunk_index": 947,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "709",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
processus d’ajout d’une version. Si vous créez une API avec des versions activées au début, une
Original version n’est pas créée.
Gestion des API gère une ressource appelée ensemble de versions, qui représente un ensemble
de versions pour une API logique unique. Un jeu de versions contient le nom complet de l’API
versionnée et le schéma de contrôle de version utilisé pour diriger les requêtes vers les
versions spécifiées.
Chaque version d’une API est conservée en tant que ressource d’API et associée à un jeu de
versions. Un jeu de versions peut contenir des API avec différentes opérations ou stratégies.
Vous pouvez apporter des modifications significatives entre les versions d’un ensemble.
Le portail Azure crée des ensembles de versions pour vous. Vous pouvez modifier le nom et la
description d’un ensemble de versions dans le portail Azure.
Un jeu de versions est automatiquement supprimé lorsque la version finale est supprimée.
Vous pouvez afficher et gérer directement les ensembles de versions à l’aide d’Azure CLI,
d’Azure PowerShell, de modèles Resource Manager ou de l’API Azure Resource Manager.
Lorsque vous utilisez le portail Azure pour activer le contrôle de version sur une API existante,
les modifications suivantes sont apportées à vos ressources Gestion des API :
Un jeu de versions est créé.
La version existante est conservée et configurée comme version de l’APIOriginal. L’API est
liée au jeu de versions, mais un identificateur de version n’a pas besoin d’être spécifié.
La nouvelle version est créée en tant que nouvelle API et est liée à l'ensemble de versions.
Un schéma et un identificateur de contrôle de version doivent être utilisés pour accéder à
la nouvelle API.
Représentation des versions
７ Notes
Toutes les versions d’un jeu de versions ont le même schéma de versionnement. Elle est
basée sur le schéma de contrôle de version utilisé lors de la première ajout d’une version à
une API.
Migration d’une API non versionnée vers | [
-0.035112712532281876,
-0.0017233650432899594,
-0.02520965412259102,
-0.030593737959861755,
0.07945679128170013,
0.03579038381576538,
0.015545113943517208,
0.023641053587198257,
-0.04338729381561279,
-0.07102224230766296,
-0.016952883452177048,
-0.05972234532237053,
-0.11384177207946777,
0... | {
"azure_component": "network",
"chunk_index": 948,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "710",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
schéma et un identificateur de contrôle de version doivent être utilisés pour accéder à
la nouvelle API.
Représentation des versions
７ Notes
Toutes les versions d’un jeu de versions ont le même schéma de versionnement. Elle est
basée sur le schéma de contrôle de version utilisé lors de la première ajout d’une version à
une API.
Migration d’une API non versionnée vers une API avec version
Versions et révisions | [
-0.038297198712825775,
0.014345481991767883,
-0.026214266195893288,
-0.022245902568101883,
0.07100825756788254,
0.01119184773415327,
0.025649264454841614,
0.001991645898669958,
-0.06605957448482513,
-0.02981387823820114,
-0.010709775611758232,
-0.028498781844973564,
-0.08158142119646072,
0... | {
"azure_component": "network",
"chunk_index": 949,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "710",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Les versions et les révisions sont des fonctionnalités distinctes. Chaque version peut avoir
plusieurs révisions, comme une API non versionnée. Vous pouvez utiliser des révisions sans
utiliser de versions, ou d’une autre façon. En règle générale, les versions sont utilisées pour
séparer les versions d’API qui ont des modifications cassantes, et les révisions peuvent être
utilisées pour les modifications mineures et non cassantes apportées à une API.
Si vous constatez que votre révision a des changements cassants ou que vous souhaitez
transformer formellement votre révision en version bêta/test, vous pouvez créer une version à
partir d’une révision. Dans le portail Azure, sélectionnez Créer une version à partir de cette
révision dans le menu contextuel de révision (...) sous l’onglet Révisions .
Le portail des développeurs répertorie chaque version d’une API séparément :
Dans les détails d’une API, vous pouvez également voir la liste de toutes les versions de l’API.
Une Original version s’affiche sans identificateur de version :
Portail des développeurs
| [
-0.00587920518592,
-0.008307773619890213,
-0.006336934864521027,
0.005452508106827736,
0.06778222322463989,
0.0630117729306221,
0.03654593229293823,
0.04860175400972366,
-0.08490128070116043,
-0.07370557636022568,
0.001761304447427392,
0.001133597339503467,
-0.09700889885425568,
0.02255621... | {
"azure_component": "network",
"chunk_index": 950,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "711",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Conseil
Vous devez ajouter des versions d’API à un produit pour les rendre visibles dans le portail
des développeurs. | [
-0.011818280443549156,
0.0032288706861436367,
0.0015236294129863381,
0.00008056384831434116,
0.05275852605700493,
0.041613172739744186,
0.012562301009893417,
0.03115975670516491,
-0.06664147973060608,
-0.049425721168518066,
-0.005451996810734272,
-0.014752287417650223,
-0.08798616379499435,
... | {
"azure_component": "network",
"chunk_index": 951,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "712",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Révisions dans Gestion des API Azure
Article • 28/04/2023
Les révisions vous permettent d’apporter des modifications à vos API de manière
contrôlée et sécurisée. Lorsque vous souhaitez apporter des modifications, créez une
nouvelle révision. Vous pouvez ensuite modifier et tester l’API, sans perturber vos
consommateurs d’API. Lorsque vous êtes prêt, vous rendez votre révision actuelle. Ce
faisant, vous pouvez publier une entrée dans le journal des modifications pour informer
vos consommateurs d’API des changements. Le journal des modifications est publié sur
le portail des développeurs.
Avec les révisions, vous pouvez :
Apporter des modifications en toute sécurité à vos définitions et stratégies d’API,
sans affecter votre API de production.
Essayer des modifications avant de les publier.
Documenter les modifications que vous apportez pour permettre aux
développeurs de comprendre les nouveautés.
Procéder à une restauration en cas de problèmes.
Prenez en main les révisions en suivant notre procédure pas à pas.
Chaque révision de votre API est accessible à l’aide d’une URL spécialement formée.
Ajoutez ;rev={revisionNumber} à la fin de votre URL d’API, avant la chaîne de requête,
pour accéder à une révision spécifique de cette API. Par exemple, vous pouvez utiliser
cette URL pour accéder à la révision 3 de l’API customers :
https://apis.contoso.com/customers;rev=3/leads?customerId=123
Par défaut, chaque révision présente les mêmes paramètres de sécurité que la révision
actuelle. Vous pouvez modifier délibérément les stratégies d’une révision spécifique
pour appliquer une sécurité différente à chaque révision. Par exemple, vous souhaiterez
peut-être ajouter une stratégie de filtrage d’adresses IP pour empêcher les appelants
externes d’accéder à une révision en cours de développement.
７ | [
0.005332533735781908,
-0.026875369250774384,
-0.02093856781721115,
-0.013610487803816795,
0.04537597671151161,
0.04641641303896904,
0.029412422329187393,
0.007196680177003145,
-0.07008607685565948,
-0.0698511153459549,
-0.02593015879392624,
-0.011466027237474918,
-0.06940720975399017,
0.01... | {
"azure_component": "network",
"chunk_index": 952,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "713",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
les mêmes paramètres de sécurité que la révision
actuelle. Vous pouvez modifier délibérément les stratégies d’une révision spécifique
pour appliquer une sécurité différente à chaque révision. Par exemple, vous souhaiterez
peut-être ajouter une stratégie de filtrage d’adresses IP pour empêcher les appelants
externes d’accéder à une révision en cours de développement.
７ Notes
Le portail des développeurs n’est pas disponible dans le niveau de consommation.
Accès à des révisions spécifiques | [
0.001911648316308856,
-0.020405150949954987,
-0.0187282245606184,
0.0375404953956604,
0.06437910348176956,
0.04875628650188446,
0.022369330748915672,
-0.003985053393989801,
-0.07089643180370331,
-0.06310969591140747,
-0.00401325011625886,
0.006278671324253082,
-0.04826507344841957,
0.01413... | {
"azure_component": "network",
"chunk_index": 953,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "713",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Une seule révision peut être définie en tant que révision actuelle. Cette révision sera
utilisée pour toutes les requêtes d’API ne spécifiant pas de numéro de révision explicite
dans l’URL. Vous pouvez restaurer une révision précédente en définissant cette révision
comme actuelle.
Vous pouvez définir une révision comme actuelle à l’aide du portail Azure. Si vous
utilisez PowerShell, vous pouvez utiliser la cmdlet New-AzApiManagementApiRelease.
Lorsque vous créez une révision, vous pouvez définir une description à des fins de suivi
personnel. Les descriptions ne sont pas affichées par les utilisateurs de votre API.
Lorsque vous définissez une révision comme actuelle, vous pouvez également spécifier
une note de journal des modifications public. Le journal des modifications est disponible
dans le portail des développeurs pour permettre à vos utilisateurs d’API de le consulter.
Vous pouvez modifier votre note de journal des modifications à l’aide de la cmdlet
PowerShell Update-AzApiManagementApiRelease.
７ Notes
;rev={id} doit être ajouté à l’ID d’API, et non au chemin d’URI.
Révision actuelle
Descriptions des révisions
Ｕ Attention
Si vous modifiez une révision non actuelle d’une API, vous ne pouvez pas changer
les propriétés suivantes :
Nom
Type
Description
Abonnement obligatoire
Version de l'API
Description de la version de l’API
Path
Protocoles | [
0.00323180528357625,
-0.029626693576574326,
-0.02644103206694126,
0.0016090312274172902,
0.07600080221891403,
0.04301130026578903,
0.031245216727256775,
0.04619806632399559,
-0.038531672209501266,
-0.05297150835394859,
-0.021314730867743492,
-0.006906453985720873,
-0.0386546291410923,
0.00... | {
"azure_component": "network",
"chunk_index": 954,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "714",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Une révision peut être mise hors connexion, ce qui la rend inaccessible aux appelants,
même s’ils essaient d’accéder à la révision via son URL. Vous pouvez marquer une
révision comme hors connexion à l’aide du portail Azure.
Les versions et les révisions constituent des fonctionnalités distinctes. Chaque version
peut présenter plusieurs révisions, tout comme il peut exister une API sans version. Vous
pouvez utiliser des révisions sans utiliser de versions ou inversement. En général, les
versions sont utilisées pour distinguer les versions d’API avec changements cassants,
tandis que les révisions peuvent être utilisées pour les changements mineurs et non
cassants apportés à une API.
Si vous pensez que votre révision présente des changements cassants ou si vous
souhaitez formellement faire évoluer votre révision en version bêta/test, vous pouvez
créer une version à partir d’une révision. À l’aide du portail Azure, cliquez sur « Créer
une version à partir de la révision » dans le menu contextuel de révision sous l’onglet
Révisions.
Ces propriétés ne peuvent être modifiées que dans la révision actuelle. Si vos
modifications changent l’une des propriétés ci-dessus d’une révision non actuelle,
le message d’erreur Can't change property for non-current revision s’affiche.
Effectuer une révision hors connexion
７ Notes
Nous vous suggérons de procéder aux révisions hors connexion lorsque vous ne les
utilisez pas à des fins de test.
Versions et révisions | [
-0.021593596786260605,
0.008914273232221603,
-0.014435343444347382,
0.027877936139702797,
0.059660717844963074,
0.03647538274526596,
0.04981173947453499,
0.05877961590886116,
-0.07397274672985077,
-0.0752742812037468,
-0.01032646931707859,
0.015012649819254875,
-0.07416456192731857,
0.0237... | {
"azure_component": "network",
"chunk_index": 955,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "715",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Serveurs principaux dans Gestion des API
06/06/2025
S’APPLIQUE À : Tous les niveaux de Gestion des API
Un service principal (ou API back-end) dans Gestion des API est un service HTTP qui
implémente votre API frontale et ses opérations.
Lors de l’importation de certaines API, Gestion des API configure automatiquement l’API back-
end. Par exemple, le service Gestion des API configure le service web back-end lors de
l’importation :
Une spécification OpenAPI.
Une API SOAP.
Ressources Azure, telles qu’une API Azure OpenAI, une application de fonction Azure
déclenchée par HTTP ou une application logique.
La Gestion des API prend également en charge l’utilisation d’autres ressources Azure, comme
un back-end d’API, par exemple :
Un cluster Service Fabric.
Un service personnalisé.
La Gestion des API prend en charge les entités de back-end personnalisés afin que vous
puissiez gérer les services back-end de votre API. Une entité back-end encapsule des
informations sur le service back-end, favorisant la réutilisation entre les API et améliorant la
gouvernance.
Utilisez des back-ends pour une ou plusieurs des actions suivantes :
Autoriser les informations d’identification des requêtes au service back-end
Utilisez la fonctionnalité de Gestion des API pour gérer les secrets dans Azure Key Vault si
des valeurs nommées sont configurées pour l’authentification de paramètre de requête
ou d’en-tête.
Définir des règles de disjoncteur pour protéger votre back-end contre un trop grand
nombre de requêtes
Acheminer ou équilibrer la charge des requêtes vers plusieurs back-ends
Configurez et gérez les entités back-end personnalisés dans le Portail Azure, ou bien à l’aide
d’API ou d’outils Azure.
Avantages des serveurs principaux | [
-0.0260270107537508,
-0.008721789345145226,
-0.021756630390882492,
-0.021185945719480515,
0.030693156644701958,
0.014961170963943005,
0.041331950575113297,
0.03604058548808098,
-0.04110786318778992,
-0.05257664620876312,
-0.03871728107333183,
-0.06756012886762619,
-0.027665268629789352,
0.... | {
"azure_component": "network",
"chunk_index": 956,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "716",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Vous pouvez créer un back-end dans le portail Azure, ou à l’aide d’API ou d’outils Azure.
Pour créer un back-end dans le portail :
1. Connectez-vous au portail
et accédez à votre instance Gestion des API.
2. Dans le menu de gauche, sélectionnez API>Backends>+ Créer un serveur principal.
3. Dans la page Back-end , procédez comme suit :
a. Entrez un nom pour le back-end et la description facultative.
b. Sélectionnez un type d’hébergement principal, par exemple, une ressource Azure
pour une ressource Azure telle qu’une application de fonction ou une application
logique, une URL personnalisée pour un service personnalisé ou un cluster Service
Fabric .
c. Dans l’URL du runtime, entrez l’URL du service principal vers lequel les demandes
d’API sont transférées.
d. Sous Avancé, désactivez éventuellement la validation de la chaîne de certificats ou du
nom de certificat pour le serveur principal.
e. Sous Ajouter ce service principal à un pool principal, sélectionnez ou créez
éventuellement un pool à charge équilibrée pour le serveur principal.
f. Sous règle de disjoncteur, configurez éventuellement un disjoncteur pour le back-end.
g. Sous Informations d’identification d’autorisation, configurez éventuellement les
informations d’identification pour autoriser l’accès au serveur principal. Les options
incluent un en-tête de requête, un paramètre de requête, un certificat client ou une
identité managée affectée par le système ou affectée par l’utilisateur configurée dans
l’instance Gestion des API.
h. Cliquez sur Créer.
Après avoir créé un back-end, vous pouvez mettre à jour les paramètres du back-end à tout
moment. Par exemple, ajoutez une règle de disjoncteur, modifiez l’URL du runtime ou ajoutez
des informations d’identification d’autorisation.
Vous pouvez utiliser une identité managée affectée | [
-0.04045185074210167,
-0.0022080393973737955,
-0.016633909195661545,
-0.03921986743807793,
0.021745095029473305,
0.03162435442209244,
0.014068172313272953,
0.050294410437345505,
-0.01896039955317974,
-0.052757952362298965,
-0.028562281280755997,
-0.029788320884108543,
-0.04463358223438263,
... | {
"azure_component": "network",
"chunk_index": 957,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "717",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
configurée dans
l’instance Gestion des API.
h. Cliquez sur Créer.
Après avoir créé un back-end, vous pouvez mettre à jour les paramètres du back-end à tout
moment. Par exemple, ajoutez une règle de disjoncteur, modifiez l’URL du runtime ou ajoutez
des informations d’identification d’autorisation.
Vous pouvez utiliser une identité managée affectée par le système ou affectée par l’utilisateur
configurée dans l’instance Gestion des API pour autoriser l’accès au service principal. Pour
configurer une identité managée pour les informations d’identification d’autorisation, procédez
comme suit :
1. Dans la section Informations d’identification d’autorisation de la configuration back-
end, sélectionnez l’onglet Identité managée , puis activez.
Création d'un serveur principal
Configurer l’identité gérée pour les certificats d'autorisation | [
-0.026802504435181618,
-0.00045558600686490536,
-0.022704435512423515,
-0.03146480396389961,
0.042212747037410736,
0.031051956117153168,
0.0487351268529892,
0.00765720009803772,
-0.04336849972605705,
-0.024829110130667686,
-0.03793998435139656,
-0.033099252730607986,
-0.048724330961704254,
... | {
"azure_component": "network",
"chunk_index": 958,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "717",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
2. Dans l’identité du client, sélectionnez l’identité affectée par le système ou une identité
affectée par l’utilisateur configurée dans votre instance.
3. Dans l’ID de ressource, entrez un service Azure cible ou l’ID d’application de votre propre
application Microsoft Entra représentant le back-end. Exemple :
https://cognitiveservices.azure.com pour le service Azure OpenAI.
Pour plus d’exemples, consultez la référence de stratégie d’authentification gérée par
identité.
4. Cliquez sur Créer.
Après avoir créé un back-end, vous pouvez référencer l’identificateur principal (nom) dans vos
API. Utilisez la stratégie set-backend-service pour diriger une requête d’API entrante vers le
back-end. Si vous avez déjà configuré un service web principal pour une API, vous pouvez
utiliser la stratégie set-backend-service pour rediriger la requête vers une entité back-end à la
place. Par exemple :
XML
７ Notes
Attribuez également à l’identité managée les autorisations appropriées ou un rôle RBAC
pour accéder au service principal. Par exemple, si le back-end est un service Azure OpenAI,
vous pouvez affecter l’identité managée au Cognitive Services User rôle.
Référencer le back-end à l’aide de la stratégie set-
backend-service
<policies>
<inbound>
<base />
<set-backend-service backend-id="myBackend" />
</inbound>
[...]
<policies/>
７ Notes
Vous pouvez également utiliser base-url . En règle générale, le format est
https://backend.com/api . Évitez d’ajouter une barre oblique à la fin pour empêcher les | [
-0.04029076546430588,
0.003921325318515301,
-0.025368934497237206,
-0.036886680871248245,
0.04559137299656868,
0.04481913894414902,
0.030855437740683556,
0.020372139289975166,
-0.017289666458964348,
-0.07807624340057373,
-0.014228645712137222,
-0.046188823878765106,
-0.04037335515022278,
0... | {
"azure_component": "network",
"chunk_index": 959,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "718",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Vous pouvez utiliser la logique conditionnelle avec la stratégie set-backend-service pour
modifier le back-end effectif en fonction de l’emplacement, de la passerelle appelée ou
d’autres expressions.
Par exemple, voici une stratégie permettant d’acheminer le trafic vers un autre back-end en
fonction de la passerelle appelée :
XML
Gestion des API expose une propriété de disjoncteur dans la ressource back-end pour protéger
un service back-end d’une submersion par trop de requêtes.
La propriété disjoncteur définit des règles pour effectuer le déclenchement du
disjoncteur, telles que le nombre ou le pourcentage de conditions d’échec pendant un
intervalle de temps défini et une plage d’état des codes qui indiquent des défaillances.
Lorsque le disjoncteur se déclenche, la gestion des API arrête d’envoyer des requêtes au
service back-end pendant une durée définie et retourne une réponse 503 Service
Indisponible au client.
Après la durée du trajet configurée, le circuit se réinitialise et le trafic reprend vers le
back-end.
erreurs de configuration. En règle générale, la valeur de base-url et la valeur du point de
terminaison HTTP(S) dans le back-end doivent correspondre pour permettre une
intégration transparente entre le serveur frontal et le serveur principal. Notez que les
instances de la Gestion des API ajoutent le nom du service principal à base-url .
<policies>
<inbound>
<base />
<choose>
<when condition="@(context.Deployment.Gateway.Id == "factory-
gateway")">
<set-backend-service backend-id="backend-on-prem" />
</when>
<when condition="@(context.Deployment.Gateway.IsManaged == false)">
<set-backend-service backend-id="self-hosted-backend" />
</when>
<otherwise />
</choose>
</inbound>
[...]
<policies/>
Disjoncteur | [
-0.04700622335076332,
0.013604957610368729,
0.0006252301391214132,
-0.051530659198760986,
0.04837053269147873,
0.03613344952464104,
0.03358888998627663,
0.040411777794361115,
-0.07742584496736526,
-0.07588334381580353,
-0.02750655822455883,
-0.013825497590005398,
-0.02047174610197544,
0.02... | {
"azure_component": "network",
"chunk_index": 960,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "719",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Le disjoncteur du back-end est une implémentation du modèle de disjoncteur pour permettre
au back-end de se rétablir après des situations de surcharge. Il augmente les stratégies
générales de limitation de débit et de limitation de concurrence que vous pouvez implémenter
pour protéger la passerelle de la gestion des API et de vos services back-end.
Utilisez le portail Azure, l’API REST Gestion des API ou un modèle Bicep ou ARM pour
configurer un disjoncteur dans un back-end. Dans l’exemple suivant, le disjoncteur dans
myBackend, dans l’instance Gestion des API myAPIM, se déclenche lorsqu’il existe trois codes
d’état 5xx (ou plus) indiquant des erreurs de serveur en une heure.
Le disjoncteur de cet exemple se réinitialise après 1 heure. Si un en-tête Retry-After est
présent dans la réponse, le disjoncteur accepte la valeur et attend l’heure spécifiée avant
l’envoi de nouvelles requêtes au back-end.
1. Dans le portail Azure
, accédez à votre instance Gestion des API.
2. Dans le menu de gauche, sélectionnez les> APIBack-ends> de votre back-end.
3. Dans la page back-end, sélectionnez Paramètres>Paramètres du
disjoncteur>Ajouter un nouveau.
4. Dans la page Créer un disjoncteur , configurez la règle :
Nom de la règle : entrez un nom pour la règle, par exemple myBackend.
Nombre d’échecs : entrez 3.
Intervalle d’échec : conservez la valeur par défaut de 1 heure.
Plage de codes d’état d’échec : sélectionnez 500 à 599.
Durée du trajet : conservez la valeur par défaut de 1 heure.
７ Notes
Actuellement, le disjoncteur de back-end n’est pas pris en charge au niveau
Consommation de la Gestion des API.
En raison de la nature distribuée de | [
-0.037804014980793,
-0.038904137909412384,
-0.04452744498848915,
-0.023974517360329628,
0.014551694504916668,
0.009323329664766788,
0.035991210490465164,
0.0341656357049942,
-0.042846281081438065,
-0.040648236870765686,
0.0019849990494549274,
-0.028832918033003807,
-0.02677333354949951,
0.... | {
"azure_component": "network",
"chunk_index": 961,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "720",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
: conservez la valeur par défaut de 1 heure.
Plage de codes d’état d’échec : sélectionnez 500 à 599.
Durée du trajet : conservez la valeur par défaut de 1 heure.
７ Notes
Actuellement, le disjoncteur de back-end n’est pas pris en charge au niveau
Consommation de la Gestion des API.
En raison de la nature distribuée de l’architecture de la Gestion des API, les règles de
déclenchement du disjoncteur sont approximatives. Différentes instances de la
passerelle ne se synchronisent pas et appliquent des règles de disjoncteur en
fonction des informations sur la même instance.
Actuellement, une seule règle peut être configurée pour un disjoncteur de back-end.
Exemple
portail | [
0.01183573342859745,
-0.012194381095468998,
-0.013917109929025173,
-0.007651923689991236,
0.05325924605131149,
0.006290176417678595,
0.012498407624661922,
0.041422292590141296,
-0.049711912870407104,
-0.0449836440384388,
0.004282404202967882,
-0.03720220923423767,
-0.037818677723407745,
-0... | {
"azure_component": "network",
"chunk_index": 962,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "720",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Cochez l’en-tête « Retry-After » dans la réponse HTTP : Sélectionnez True
(Accepter).
Gestion des API prend en charge les pools back-ends, lorsque vous souhaitez implémenter
plusieurs back-ends pour une API et équilibrer la charge des requêtes entre ces back-ends. Un
pool est une collection de back-ends qui sont traités comme une entité unique pour
l’équilibrage de charge.
Utilisez un pool de back-ends pour des scénarios tels que les suivants :
Répartir la charge sur plusieurs back-ends, ce qui peut avoir des disjoncteurs de back-end
individuels.
Déplacer la charge d’un ensemble de back-ends vers un autre pour la mise à niveau
(déploiement bleu-vert).
Gestion des API prend en charge les options d’équilibrage de charge suivantes pour les pools
back-end :
Option
d’équilibrage de
charge
Descriptif
Tourniquet (round
robin)
Les requêtes sont distribuées uniformément entre les back-ends du pool par
défaut.
Pool à équilibrage de charge
７ Notes
Vous pouvez inclure jusqu’à 30 back-ends par pool.
En raison de la nature distribuée de l’architecture de Gestion des API, l’équilibrage de
charge de back-end est approximatif. Différentes instances de la passerelle ne se
synchronisent pas et équilibrent la charge en fonction des informations sur la même
instance.
Options d’équilibrage de charge
ﾉ
Agrandir le tableau | [
-0.028707386925816536,
-0.057897865772247314,
-0.01885773427784443,
-0.012353206984698772,
0.043044377118349075,
0.028916139155626297,
-0.0327676385641098,
0.03904369845986366,
-0.06130340322852135,
-0.05163318291306496,
0.006375682074576616,
0.007120874710381031,
-0.03415309637784958,
-0.... | {
"azure_component": "network",
"chunk_index": 963,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "721",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Option
d’équilibrage de
charge
Descriptif
pondéré
Les pondérations sont affectées aux back-ends du pool, et les requêtes sont
distribuées en fonction du poids relatif de chaque back-end. Utile pour les
scénarios tels que les déploiements bleu-vert.
Basé sur la priorité
Les backends sont organisés en groupes de priorité. Les demandes sont envoyées
d’abord à des groupes de priorité supérieure ; au sein d’un groupe, les requêtes
sont distribuées uniformément ou en fonction des pondérations attribuées.
Avec l’une des options d’équilibrage de charge précédentes, activez éventuellement la prise en
charge de la session (affinité de session) pour vous assurer que toutes les demandes d’un
utilisateur spécifique pendant une session sont dirigées vers le même back-end dans le pool.
Gestion des API définit un cookie d’ID de session pour maintenir l’état de session. Cette option
est utile, par exemple, dans les scénarios avec des back-ends tels que des assistants de
conversation IA ou d’autres agents conversationnels pour acheminer les demandes de la même
session vers le même point de terminaison.
Lors de l’utilisation de la sensibilisation à la session, le client doit gérer les cookies de manière
appropriée. Le client doit stocker la valeur d’en-tête et l’envoyer avec les demandes suivantes
pour maintenir l’état Set-Cookie de session.
Vous pouvez utiliser des stratégies Gestion des API pour vous aider à définir des cookies pour
la sensibilisation à la session. Par exemple, pour le cas de l’API Assistants (fonctionnalité
７ Notes
Les back-ends dans les groupes de priorité inférieure ne sont utilisés que lorsque tous les
back-ends des groupes de priorité supérieure ne sont pas disponibles, car les règles de
disjoncteur sont triplées.
Sensibilisation à la session
７ Notes
La sensibilisation à la session dans les | [
-0.05674908682703972,
-0.05199839547276497,
-0.03366358205676079,
-0.015465958043932915,
0.0264374241232872,
0.016421997919678688,
-0.01775295101106167,
0.042448583990335464,
-0.04266161471605301,
-0.07625129818916321,
-0.04531821608543396,
0.03698185831308365,
-0.03701961413025856,
-0.009... | {
"azure_component": "network",
"chunk_index": 964,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "722",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Par exemple, pour le cas de l’API Assistants (fonctionnalité
７ Notes
Les back-ends dans les groupes de priorité inférieure ne sont utilisés que lorsque tous les
back-ends des groupes de priorité supérieure ne sont pas disponibles, car les règles de
disjoncteur sont triplées.
Sensibilisation à la session
７ Notes
La sensibilisation à la session dans les pools à charge équilibrée est publiée en premier
dans le groupe de mises à jour anticipées de la passerelle AI.
Gérer les cookies pour la sensibilisation à la session | [
-0.006307155825197697,
-0.01962350495159626,
0.013299394398927689,
-0.0004983844701200724,
0.01907862164080143,
0.021152222529053688,
0.031734175980091095,
0.015374288894236088,
-0.04175238683819771,
-0.036632150411605835,
-0.013636652380228043,
0.017455942928791046,
-0.06025964021682739,
... | {
"azure_component": "network",
"chunk_index": 965,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "722",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
d’Azure OpenAI dans Azure AI Foundry Models), le client doit conserver l’ID de session, extraire
l’ID de thread du corps et conserver la paire et envoyer le cookie approprié pour chaque appel.
De plus, le client doit savoir quand envoyer un cookie ou quand ne pas envoyer un en-tête de
cookie. Ces exigences peuvent être gérées de manière appropriée en définissant les exemples
de stratégies suivants :
XML
Utilisez le portail, l’API REST Gestion des API ou un modèle Bicep ou ARM pour configurer un
pool principal. Dans l’exemple suivant, le serveur principal myBackendPool dans l’instance de
Gestion des API myAPIM est configuré avec un pool principal. Les exemples de back-end du
pool sont nommés backend-1 et backend-2. Les deux back-ends se trouvent dans le groupe de
priorité le plus élevé ; dans le groupe, backend-1 a un poids supérieur à backend-2.
<policies>
<inbound>
<base />
<set-backend-service backend-id="APIMBackend" />
</inbound>
<backend>
<base />
</backend>
<outbound>
<base />
<set-variable name="gwSetCookie" value="@{
var payload = context.Response.Body.As<JObject>();
var threadId = payload["id"];
var gwSetCookieHeaderValue =
context.Request.Headers.GetValueOrDefault("SetCookie", string.Empty);
if(!string.IsNullOrEmpty(gwSetCookieHeaderValue))
{
gwSetCookieHeaderValue = gwSetCookieHeaderValue + | [
-0.042058054357767105,
-0.016130704432725906,
-0.011342915706336498,
-0.028966275975108147,
0.03491940349340439,
0.025892285630106926,
0.04653792455792427,
0.044705674052238464,
-0.02333446778357029,
-0.06661395728588104,
0.015177288092672825,
-0.041593533009290695,
-0.052186138927936554,
... | {
"azure_component": "network",
"chunk_index": 966,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "723",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
payload["id"];
var gwSetCookieHeaderValue =
context.Request.Headers.GetValueOrDefault("SetCookie", string.Empty);
if(!string.IsNullOrEmpty(gwSetCookieHeaderValue))
{
gwSetCookieHeaderValue = gwSetCookieHeaderValue +
$";Path=/threads/{threadId};";
}
return gwSetCookieHeaderValue;
}" />
<set-header name="Set-Cookie" exists-action="override">
<value>Cookie=gwSetCookieHeaderValue</value>
</set-header>
</outbound>
<on-error>
<base />
</on-error>
</policies>
Exemple
portail | [
-0.01585523597896099,
-0.020176799967885017,
-0.009912677109241486,
-0.003120271721854806,
0.04484608769416809,
-0.015210320241749287,
0.05736050009727478,
0.0258480291813612,
-0.0070533412508666515,
-0.056849874556064606,
-0.0015496783889830112,
-0.017438042908906937,
-0.09173355251550674,
... | {
"azure_component": "network",
"chunk_index": 967,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "723",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
1. Dans le portail Azure
, accédez à votre instance Gestion des API.
2. Dans le menu de gauche, sélectionnez les> APIBack-ends> de votre back-end.
3. Dans la page Back-ends , sélectionnez l’onglet Équilibreur de charge .
4. Sélectionnez + Créer un pool.
5. Dans la page Créer un pool à charge équilibrée , procédez comme suit :
Nom : entrez un nom pour le pool tel que myBackendPool.
Description : Si vous le souhaitez, entrez une description.
Ajouter des back-ends au pool : sélectionnez un ou plusieurs back-ends à
ajouter au pool.
Poids et priorité du back-end : sélectionnez Personnaliser l’épaisseur et la
priorité pour configurer l’épaisseur et la priorité de chaque back-end du pool.
Par exemple, si vous avez ajouté deux back-ends nommés backend-1 et
backend-2, définissez le poids du back-1 sur 3 et le poids du back-end-2 à 1 et
définissez la priorité des deux back-ends sur 1.
Cliquez sur Créer.
Pour les niveaux Développeur et Premium, une instance Gestion des API déployée dans
un réseau virtuel interne peut générer des erreurs HTTP 500 BackendConnectionFailure
quand l’URL du point de terminaison de passerelle et l’URL du back-end sont identiques.
Si vous rencontrez cette limitation, suivez les instructions fournies dans l’article Limitation
des demandes de la Gestion des API autochaînées en mode réseau virtuel interne
du
blog de la communauté technique.
Actuellement, une seule règle peut être configurée pour un disjoncteur de back-end.
Blog : Utilisation du disjoncteur Gestion des API Azure et de l’équilibrage de charge avec
Azure OpenAI Service
Configurez un serveur principal Service Fabric à l’aide du portail Azure.
Guide de démarrage rapide Créer un pool principal dans la Gestion des API Azure à l’aide
de | [
-0.04976354166865349,
-0.0448015034198761,
-0.02640346996486187,
-0.026028316468000412,
0.02370908111333847,
0.035101547837257385,
0.005376643035560846,
0.04409732297062874,
-0.05991191789507866,
-0.0730740949511528,
-0.00466834707185626,
-0.01695120707154274,
-0.03622223064303398,
0.01970... | {
"azure_component": "network",
"chunk_index": 968,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "724",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
technique.
Actuellement, une seule règle peut être configurée pour un disjoncteur de back-end.
Blog : Utilisation du disjoncteur Gestion des API Azure et de l’équilibrage de charge avec
Azure OpenAI Service
Configurez un serveur principal Service Fabric à l’aide du portail Azure.
Guide de démarrage rapide Créer un pool principal dans la Gestion des API Azure à l’aide
de Bicep pour équilibrer la charge des requêtes OpenAI
Voir Azure API Management à titre de source Event Grid pour obtenir des informations
sur les événements Event Grid générés par la passerelle lorsqu’un disjoncteur est
déclenché ou réinitialisé. Utilisez ces événements pour prendre des mesures avant
l’escalade des problèmes principaux.
Limites
Contenu connexe | [
-0.020810531452298164,
-0.03135504573583603,
-0.04690591245889664,
-0.0220896378159523,
0.031464073807001114,
-0.0018100005108863115,
0.03020547516644001,
0.016156109049916267,
-0.027447838336229324,
-0.0441131629049778,
0.009030194953083992,
-0.042124055325984955,
-0.07282247394323349,
0.... | {
"azure_component": "network",
"chunk_index": 969,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "724",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Déploiements d’API automatisés
avec APIOps
Gestion des API Azure
Azure DevOps
Azure Pipelines
APIOps est une méthodologie qui applique les concepts de GitOps et DevOps au déploiement
d’API. Comme DevOps, APIOps
aide les membres de l’équipe à apporter facilement des
modifications et à les déployer de manière itérative et automatisée. Cette architecture montre
comment vous pouvez améliorer l’ensemble du cycle de vie et de la qualité de l’API en utilisant
APIOps.
Téléchargez un fichier Visio
de cette architecture.
1. Les opérateurs d’API exécutent le pipeline d’extracteur
pour synchroniser le référentiel
Git avec l’instance Gestion des API et remplir le référentiel Git avec des objets Gestion des
API au format requis.
Architecture
CI/CD
Review changes
Approve PR
Create PR
API
developers
API operators
Git repo
Pull request
(PR)
Merge
Design, create, and
test OpenAPI
specification
Extractor pipeline
Publisher pipeline
API Management
instance
Sync Azure
API Management
state in Git repo
Products logger and
diagnostics
API service information
Azure API
Management Policy
API definition
Create PR
1
2
3
4
5
6
7
8
9
Flux de travail | [
0.009321555495262146,
-0.007748779840767384,
-0.02122977003455162,
-0.005491039250046015,
0.012223130092024803,
0.06362738460302353,
0.014782434329390526,
0.060695830732584,
-0.028398290276527405,
-0.0524650476872921,
-0.040568672120571136,
-0.049970000982284546,
-0.09224379807710648,
0.03... | {
"azure_component": "network",
"chunk_index": 970,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "725",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
2. Si une modification de l’API est détectée dans l’instance Gestion des API, une demande
de tirage (PR) est créée pour que les opérateurs soient examinés. Les opérateurs
fusionnent les modifications dans le dépôt Git.
3. Les développeurs d’API clonent le référentiel Git, créent une branche et créent des
définitions d’API à l’aide de la spécification OpenAPI ou des outils de leur choix.
4. Si un développeur pousse les modifications vers le dépôt, une demande de tirage est
créée pour révision.
5. La PR peut être approuvée ou révisée automatiquement, en fonction du niveau de
contrôle nécessaire.
6. Une fois les changements approuvés et fusionnés, le pipeline de publication déploie les
derniers changements sur l’instance Gestion des API.
7. Les opérateurs d’API créent et modifient les stratégies, les diagnostics, les produits et
d’autres objets pertinents de Gestion des API, puis valident les changements.
8. Les changements sont révisés et fusionnés après l’approbation.
9. Une fois les changements fusionnés, le pipeline de publication déploie les changements à
l’aide du processus des définitions d’API.
Gestion des API Azure crée des passerelles API cohérentes et modernes pour les services
principaux. En plus du routage des appels d’API vers les back-ends, cette plateforme
vérifie également les informations d’identification, applique les quotas d’utilisation et
journalise les métadonnées.
Azure DevOps est un service permettant de gérer votre cycle de vie de développement de
bout en bout, notamment la planification et la gestion des projets, la gestion du code et
la poursuite de la génération et de la mise en production.
Azure Pipelines permet l’intégration continue et la livraison continue (CI/CD) pour tester
et générer votre code et l’expédier | [
-0.005440196022391319,
-0.006892795208841562,
-0.03491898253560066,
0.001974718179553747,
0.052634112536907196,
0.04142044112086296,
0.02201787196099758,
0.04949384555220604,
-0.04129848629236221,
-0.048895977437496185,
-0.01384899951517582,
-0.042206060141325,
-0.0668499767780304,
0.02759... | {
"azure_component": "network",
"chunk_index": 971,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "726",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
les métadonnées.
Azure DevOps est un service permettant de gérer votre cycle de vie de développement de
bout en bout, notamment la planification et la gestion des projets, la gestion du code et
la poursuite de la génération et de la mise en production.
Azure Pipelines permet l’intégration continue et la livraison continue (CI/CD) pour tester
et générer votre code et l’expédier à n’importe quelle cible.
Azure Repos est un ensemble d’outils de contrôle de version, y compris Git standard, que
vous pouvez utiliser pour gérer votre code.
Composants
Autres solutions | [
0.021701598539948463,
-0.008414906449615955,
-0.04805316776037216,
0.041787467896938324,
0.03506162762641907,
0.03295886889100075,
0.05553654208779335,
0.07711571455001831,
-0.01020389050245285,
-0.07154624164104462,
-0.03425725921988487,
-0.0463988296687603,
-0.04997717961668968,
0.024623... | {
"azure_component": "network",
"chunk_index": 972,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "726",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Cette solution utilise Azure Repos pour fournir des fonctionnalités Git et Azure Pipelines fournit
les pipelines. Vous pouvez utiliser n’importe quelle technologie comparable.
APIOps utilise la gestion de versions pour gérer les API et créer une piste d’audit des
modifications apportées aux API, aux stratégies et aux opérations.
Les développeurs d’API qui utilisent une méthodologie APIOps révisent et auditent les API plus
tôt et plus fréquemment, interceptant et corrigeant les écarts avec les normes d’API plus
rapidement pour améliorer les spécifications et la qualité des API. Plus vous créez et déployez
d’API avec une approche APIOps, plus vous avez de cohérence entre les API.
Cette architecture APIOps utilise Gestion des API Azure comme plateforme de gestion des API.
Azure DevOps
organise la gestion des API. Azure Repos fournit des fonctionnalités Git et
Azure Pipelines crée le pipeline CI/CD.
Toute organisation qui développe et gère des API
Secteurs d’activité hautement réglementés : assurance, banque, finance, gouvernement
Ces considérations implémentent les piliers d’Azure Well-Architected Framework, un ensemble
de principes directeurs que vous pouvez utiliser pour améliorer la qualité d’une charge de
travail. Pour plus d’informations, consultez Well-Architected Framework.
La sécurité offre des garanties contre les attaques délibérées et l’utilisation abusive de vos
données et systèmes précieux. Pour plus d’informations, consultez la liste de vérification de la
révision de conception pour la sécurité.
Cette solution offre plusieurs avantages en matière de sécurité. Les développeurs individuels,
et même les opérateurs, n’accèdent pas directement à l’instance Gestion des API pour
appliquer les changements ou les mises à jour. À la place, les utilisateurs poussent les
changements dans un dépôt Git, puis l’extracteur et les pipelines de publication les lisent et les
appliquent à | [
0.019723746925592422,
0.0007165810093283653,
-0.010309015400707722,
0.03220798075199127,
0.049787651747465134,
0.08231936395168304,
0.03416784480214119,
0.07181955128908157,
-0.03696353733539581,
-0.04610666260123253,
-0.009847637265920639,
-0.041549261659383774,
-0.06893496215343475,
0.01... | {
"azure_component": "network",
"chunk_index": 973,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "727",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
solution offre plusieurs avantages en matière de sécurité. Les développeurs individuels,
et même les opérateurs, n’accèdent pas directement à l’instance Gestion des API pour
appliquer les changements ou les mises à jour. À la place, les utilisateurs poussent les
changements dans un dépôt Git, puis l’extracteur et les pipelines de publication les lisent et les
appliquent à l’instance Gestion des API. Cette approche suit la meilleure pratique de sécurité
du privilège minimum en ne donnant pas aux équipes des autorisations d’écriture sur l’instance
Détails du scénario
Cas d’usage potentiels
Considérations
Sécurité | [
-0.012700296938419342,
-0.012562423013150692,
0.0022934938315302134,
0.01816362887620926,
0.0733739584684372,
0.028328167274594307,
0.04411749914288521,
0.0056946612894535065,
-0.06573712080717087,
-0.031311824917793274,
-0.023405252024531364,
-0.025306032970547676,
-0.05922958627343178,
0... | {
"azure_component": "network",
"chunk_index": 974,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "727",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
du service Gestion des API. Dans des scénarios de diagnostic ou de résolution des problèmes,
vous pouvez accorder des autorisations élevées pendant une durée limitée au cas par cas.
Afin que les instances Gestion des API utilisent les bonnes pratiques de sécurité, vous pouvez
étendre cette solution pour appliquer les bonnes pratique de l’API en utilisant des outils tiers et
des tests unitaires. Les équipes peuvent fournir des commentaires précoces en révisant la PR si
les changements proposés sur une API ou une stratégie ne respectent pas les standards.
En plus de la configuration des autorisations de dépôt, implémentez les mesures de sécurité
suivantes dans les dépôts Git synchronisés avec les instances Gestion des API :
Révision de la demande de tirage (PULL) : utilisez des branches et protégez les branches
qui représentent l’état des instances gestion des API d’avoir des modifications envoyées
directement à ces instances. Demandez à ce que les PR bénéficient d’au moins un réviseur
afin d’appliquer le principe des quatre yeux.
Historique immuable : autorisez uniquement de nouvelles validations au-dessus des
modifications existantes. L’historique immuable est particulièrement important pour les
audits.
Authentification multifacteur : demandez à vos utilisateurs d’activer l’authentification à
deux facteurs.
Validations signées : autorisez uniquement les validations signées qui ne peuvent pas
être modifiées après le fait.
L’optimisation des coûts se concentre sur les moyens de réduire les dépenses inutiles et
d’améliorer l’efficacité opérationnelle. Pour plus d’informations, consultez la liste de contrôle
de révision de conception pour l’optimisation des coûts.
Utilisez la calculatrice de prix Azure
pour estimer les coûts.
Gestion des API offre les niveaux suivants : Consommation, Développeur, De base,
Standard et Premium.
GitHub offre un service gratuit. | [
0.00364976585842669,
-0.01757243648171425,
-0.023212943226099014,
-0.0048308600671589375,
0.03938857838511467,
0.04978276789188385,
0.041737865656614304,
0.03353458642959595,
-0.0667811781167984,
-0.03732122480869293,
-0.027752572670578957,
-0.04320744797587395,
-0.04538754001259804,
0.012... | {
"azure_component": "network",
"chunk_index": 975,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "728",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
l’efficacité opérationnelle. Pour plus d’informations, consultez la liste de contrôle
de révision de conception pour l’optimisation des coûts.
Utilisez la calculatrice de prix Azure
pour estimer les coûts.
Gestion des API offre les niveaux suivants : Consommation, Développeur, De base,
Standard et Premium.
GitHub offre un service gratuit. Toutefois, pour utiliser les fonctionnalités de sécurité
avancées, comme les propriétaires de code ou les réviseurs obligatoires, vous avez besoin
d’un Plan d’équipe. Pour plus d’informations, consultez la tarification GitHub
.
L’excellence opérationnelle couvre les processus opérationnels qui déploient une application et
la maintiennent en production. Pour plus d’informations, consultez la liste de vérification de la
révision de conception pour l’excellence opérationnelle.
Optimisation des coûts
Excellence opérationnelle | [
0.01954885572195053,
0.011479812674224377,
-0.016723932698369026,
-0.01893407292664051,
0.06062617897987366,
0.06797558814287186,
0.016260575503110886,
0.05048385262489319,
-0.06764590740203857,
-0.06210504472255707,
-0.04089030623435974,
-0.03324034810066223,
-0.0505351796746254,
0.005009... | {
"azure_component": "network",
"chunk_index": 976,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "728",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
APIOps peut augmenter la productivité DevOps pour le développement et les déploiements
d’API. L’une des fonctionnalités les plus utiles est la possibilité d’utiliser des opérations Git pour
restaurer rapidement les changements qui se comportent de manière inattendue. Le graphe de
validation contient toutes les validations pour aider l’analyse post-mortem.
Les opérateurs d’API gèrent souvent plusieurs environnements pour le même ensemble d’API.
Souvent, vous pouvez avoir plusieurs phases d’une API déployées sur différentes instances
Gestion des API ou dans une instance Gestion des API partagée. Le référentiel Git, qui est la
seule source de vérité, indique les versions des applications actuellement déployées sur un
cluster.
Quand un utilisateur crée une PR dans le dépôt Git, l’opérateur d’API sait qu’il a du nouveau
code à réviser. Par exemple, lorsqu’un développeur prend la spécification OpenAPI et génère
l’implémentation de l’API, il ajoute ce nouveau code au référentiel. Les opérateurs peuvent
réviser la PR et vérifier que l’API qui a été envoyée pour révision suit les bonnes pratiques et les
standards.
L’efficacité des performances fait référence à la capacité de votre charge de travail à mettre à
l’échelle pour répondre efficacement aux demandes des utilisateurs. Pour plus d’informations,
consultez la liste de vérification de la révision de conception pour l’efficacité des performances.
APIOps a de nombreux avantages, mais plus les paysages de Gestion des API se développent,
plus il est difficile de les gérer. Cette solution permet de relever des défis, tels que :
Avoir une vue d’ensemble de tous les environnements et instances Gestion des API.
Suivre les changements critiques des API et des stratégies.
Création d’une piste d’audit pour tous les changements déployés.
Le déploiement de cette solution implique les étapes | [
0.007900843396782875,
-0.01444484293460846,
-0.03780338168144226,
-0.007544431369751692,
0.05179130285978317,
0.0769856870174408,
0.018535448238253593,
0.07638347893953323,
-0.07825616747140884,
-0.04561257362365723,
-0.03402353823184967,
-0.021112682297825813,
-0.07294813543558121,
0.0202... | {
"azure_component": "network",
"chunk_index": 977,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "729",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
des API se développent,
plus il est difficile de les gérer. Cette solution permet de relever des défis, tels que :
Avoir une vue d’ensemble de tous les environnements et instances Gestion des API.
Suivre les changements critiques des API et des stratégies.
Création d’une piste d’audit pour tous les changements déployés.
Le déploiement de cette solution implique les étapes suivantes :
Développez l’API dans le portail ou apportez des modifications à la spécification OpenAPI
à l’aide d’un outil de votre choix.
Si vous effectuez des changements dans le portail, vous pouvez exécuter l’extracteur
pour extraire automatiquement toutes les API et d’autres stratégies, opérations et
configurations pertinentes de Gestion des API. Vous pouvez synchroniser ces
informations avec le dépôt Git.
Efficacité des performances
Déployer ce scénario | [
-0.0033726778347045183,
-0.009018737822771072,
-0.001835112925618887,
-0.0018656487809494138,
0.051397789269685745,
0.0603797547519207,
0.011376862414181232,
0.04659328982234001,
-0.0664854496717453,
-0.05966578796505928,
-0.008962543681263924,
-0.03366399556398392,
-0.07017038017511368,
-... | {
"azure_component": "network",
"chunk_index": 978,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "729",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Si vous le souhaitez, utilisez l’interface CLI Azure DevOps pour créer une demande de
tirage( pull request).
Le workflow de l’extracteur comprend les étapes suivantes :
Exécuter un pipeline qui télécharge les changements effectués dans le portail vers
l’instance Gestion des API.
Entrez les noms de la branche, de votre référentiel d’artefacts APIM, de l’instance
Gestion des API et du groupe de ressources
.
Dans notre scénario, le pipeline qui télécharge les modifications dans le portail vers
l’instance Gestion des API comporte les étapes suivantes : Extraction de build, création
d’artefacts à partir du portail et création d’une branche de modèle.
Extracteur de build
Cette étape génère le code de l’extracteur.
Créer des artefacts à partir du portail
Cette étape exécute l’extracteur et crée des artefacts qui ressemblent à une structure
de dépôt Git comme celle illustrée dans la capture d’écran suivante : | [
-0.0016056600725278258,
-0.00993260182440281,
-0.019405368715524673,
-0.0071190292946994305,
0.05239533632993698,
0.047159235924482346,
0.013754521496593952,
0.05429236218333244,
-0.01805291697382927,
-0.020400511100888252,
-0.039344944059848785,
-0.021601850166916847,
-0.08805083483457565,
... | {
"azure_component": "network",
"chunk_index": 979,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "730",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Créer une branche de modèle
Une fois l’artefact généré, cette étape crée une PR avec les changements extraits
pour que l’équipe de plateforme puisse les réviser.
La première fois que vous exécutez l’extracteur, il tire tout ce qui se trouve dans le
dépôt Git. La PR créée contient toutes les API, stratégies, artefacts, etc.
Les extractions ultérieures contiennent uniquement les changements effectués
avant l’extraction dans la PR. Parfois, les changements peuvent concerner
uniquement la spécification d’une API, ce qui est le cas dans l’exemple de PR
suivant. | [
0.0034146744292229414,
-0.008929111063480377,
-0.021282289177179337,
-0.02223576419055462,
0.054493390023708344,
0.045066606253385544,
-0.01682921312749386,
0.024243194609880447,
-0.04250110313296318,
-0.03998655080795288,
-0.04728120565414429,
-0.0033822678960859776,
-0.07220637053251266,
... | {
"azure_component": "network",
"chunk_index": 980,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "731",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Un réviseur accède aux demandes de tirage pour afficher les demandes de tirage mises à
jour. Vous pouvez également configurer des approbations automatiques pour
automatiser cette étape.
| [
0.010160396806895733,
-0.014876818284392357,
-0.004560014232993126,
0.0063675036653876305,
0.024911072105169296,
0.06457415968179703,
0.033176884055137634,
0.010437184944748878,
-0.04515734314918518,
-0.022884530946612358,
-0.009830912575125694,
0.02999703772366047,
-0.07725739479064941,
-... | {
"azure_component": "network",
"chunk_index": 981,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "732",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Une fois la PR approuvée, elle déclenche un autre pipeline dont le sens de publication
part de Gestion des API vers le portail. Dans notre exemple, il comporte les étapes
suivantes : créateur de build, fin de build et publication d’instances APIM.
La phase du créateur de build gère la création de nouvelles API.
L’étape de fin de génération gère toutes les suppressions.
La phase de publication des instances APIM publie les modifications apportées à
l’instance Gestion des API.
Après l’exécution de ce pipeline, tous les changements sont publiés dans l’instance
Gestion des API.
| [
-0.008074827492237091,
-0.010290833190083504,
-0.0058884453028440475,
-0.037346918135881424,
0.05390298739075661,
0.033575739711523056,
0.031400132924318314,
0.031092140823602676,
-0.06788790225982666,
-0.014068410731852055,
-0.0401901975274086,
-0.033199746161699295,
-0.06219739839434624,
... | {
"azure_component": "network",
"chunk_index": 982,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "733",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Cet article est géré par Microsoft. Il a été écrit à l’origine par les contributeurs suivants.
Auteur principal :
Rishabh Saha
| Architecte de solution principal
Pour afficher les profils LinkedIn non publics, connectez-vous à LinkedIn.
Azure Pipelines
APIOps pour Gestion des API Azure
CI/CD pour gestion des API à l’aide de modèles Azure Resource Manager
Vue d’ensemble de GitOps
Tisser GitOps
Tutoriel : Déployer des configurations à l’aide de GitOps sur un cluster Kubernetes avec
Azure Arc
GitOps pour Azure Kubernetes Service
Migrer une application web à l’aide de Gestion des API Azure
Protéger les API avec Application Gateway et Gestion des API
Contributeurs
Étapes suivantes
Ressources associées | [
-0.0061605642549693584,
-0.015960874035954475,
0.004956198390573263,
0.024138839915394783,
0.04668010026216507,
0.03327113389968872,
0.027538713067770004,
0.04375649616122246,
0.0036808946169912815,
-0.07026351243257523,
-0.0322684682905674,
-0.05652754008769989,
-0.061080917716026306,
0.0... | {
"azure_component": "network",
"chunk_index": 983,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "734",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Ajout de mise en cache pour améliorer les
performances dans Gestion des API Azure
06/06/2025
S’APPLIQUE À : Développeur | Essentiel | Essentiel v2 | Standard | Standard v2 | Premium |
Premium v2 | Isolé
Les API et opérations dans Gestion des API Azure peuvent être configurées pour mettre en
cache la réponse. La mise en cache des réponses peut réduire considérablement la latence
pour les appelants d’API et la charge backend pour les fournisseurs d’API. Cet article explique
comment ajouter la mise en cache à vos API.
Pour plus d’informations sur la mise en cache, consultez Stratégies de mise en cache de
Gestion des API et Mise en cache personnalisée dans Gestion des API Azure.
） Important
Le cache intégré est volatile et est partagé par toutes les unités de la même région dans la
même instance gestion des API. Quel que soit le type de cache utilisé (interne ou externe),
si les opérations liées au cache ne parviennent pas à se connecter au cache en raison de la
volatilité du cache ou pour toute autre raison, l’appel d’API qui utilise l’opération liée au
cache ne génère pas d’erreur et l’opération de cache se termine correctement. Dans le cas
d’une opération de lecture, une valeur null est retournée à l’expression de stratégie
appelante. Votre code de stratégie doit être conçu pour vous assurer qu’il existe un
mécanisme de secours pour récupérer des données introuvables dans le cache. | [
-0.008059373125433922,
-0.005172800738364458,
-0.015562151558697224,
-0.021274659782648087,
0.0307539701461792,
0.03630059212446213,
0.04991390183568001,
0.05777198448777199,
-0.0710887759923935,
-0.05311361327767372,
-0.00900442898273468,
-0.044167954474687576,
-0.04873330146074295,
0.020... | {
"azure_component": "network",
"chunk_index": 984,
"contains_sku": true,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "735",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Dans cet article, vous :
Créer une instance du service Gestion des API Azure
Importer et publier une API
Avec les stratégies de mise en cache indiquées dans cet exemple, la première requête à une
opération de test retourne une réponse du service principal. Cette réponse est mise en cache,
du fait des en-têtes et des paramètres de chaîne de requête spécifiés. Les appels suivants à
l’opération, avec des paramètres correspondants, retournent la réponse mise en cache jusqu’à
l’expiration de l’intervalle de durée du cache.
Ajouter une mise en cache des réponses pour votre API
＂
Vérifier que la mise en cache fonctionne
＂
７ Notes
La mise en cache interne n’est pas disponible dans le niveau Consommation de Gestion
des API Azure. Vous pouvez utiliser un Cache Azure pour Redis externe à la place. Vous
pouvez également configurer un cache externe dans d’autres niveaux de service de la
gestion des API.
Prérequis
Ajouter des stratégies de mise en cache | [
-0.015289791859686375,
-0.015287511050701141,
-0.03680187463760376,
-0.00018634513253346086,
0.06157858669757843,
0.038493432104587555,
0.038025863468647,
0.057258687913417816,
-0.03765494376420975,
-0.04203478991985321,
0.005504182539880276,
-0.06217915564775467,
-0.045908063650131226,
0.... | {
"azure_component": "network",
"chunk_index": 985,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "736",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
1. Connectez-vous au portail Azure
.
2. Accédez à votre instance Gestion des API.
3. Sélectionnez API>API dans le menu de gauche.
4. Sélectionnez une API pour laquelle vous souhaitez configurer la mise en cache.
5. En haut de l’écran, sélectionnez l’onglet Création .
6. Dans la section Traitement entrant, sélectionnez l’icône /> :<
7. Dans l’élément inbound , ajoutez la stratégie suivante :
XML
8. Dans l’élément outbound , ajoutez la stratégie suivante :
XML
Dans cette stratégie, duration spécifie l’intervalle d’expiration des réponses mises en
cache. L’intervalle est de 20 secondes.
<cache-lookup vary-by-developer="false" vary-by-developer-groups="false">
<vary-by-header>Accept</vary-by-header>
<vary-by-header>Accept-Charset</vary-by-header>
<vary-by-header>Authorization</vary-by-header>
</cache-lookup>
<cache-store duration="20" /> | [
-0.017048800364136696,
0.011073257774114609,
-0.02405557595193386,
-0.014145651832222939,
0.046736136078834534,
0.0335996150970459,
0.015353509224951267,
0.05039118975400925,
-0.037906400859355927,
-0.08335436880588531,
-0.034037996083498,
-0.02751556597650051,
-0.03482406586408615,
-0.017... | {
"azure_component": "network",
"chunk_index": 986,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "737",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
9. Cliquez sur Enregistrer.
Pour tester la mise en cache, appelez une opération dans le portail.
1. Dans le portail Azure, accédez à votre instance de gestion des API.
2. Sélectionnez API>API dans le menu de gauche.
3. Sélectionnez l’API à laquelle vous avez ajoutée des stratégies de mise en cache.
4. Sélectionnez une opération à tester.
5. Sélectionnez l’onglet Test en haut de la fenêtre.
6. Cliquez rapidement sur Trace deux ou trois fois de suite.
7. Sous réponse HTTP, sélectionnez l’onglet Trace.
8. Accédez à la section Entrante et faites défiler jusqu’à la cache-lookup stratégie. Vous
devriez voir un message similaire à celui de la capture d’écran suivante, qui indique un
accès au cache :
Pour plus d’informations sur les stratégies de mise en cache, voir la section Stratégies de
mise en cache dans Référence de stratégie de Gestion des API.
Pour plus d’informations sur la mise en cache des éléments par clé à l’aide d’expressions
de stratégie, consultez La mise en cache personnalisée dans Gestion des API Azure.
Pour plus d’informations sur l’utilisation d’Azure Cache pour Redis externe ou d’Azure
Managed Redis, consultez Utiliser un Cache Azure pour Redis externe dans la Gestion des
API Azure.
Conseil
Si vous utilisez un cache externe, comme décrit dans Utiliser un cache Azure externe pour
Redis dans Gestion des API Azure, vous pouvez spécifier l’attribut caching-type des
stratégies de mise en cache. Pour plus d’informations, consultez les stratégies de mise en
cache gestion des API .
Appeler une opération pour tester la mise en cache
Contenu connexe | [
0.00832455512136221,
0.004447463899850845,
-0.015852151438593864,
-0.002611041534692049,
0.06398764252662659,
0.019609952345490456,
0.015261884778738022,
0.06502407789230347,
-0.05513232946395874,
-0.061019040644168854,
-0.0013414964778348804,
-0.03799190744757652,
-0.03434449061751366,
0.... | {
"azure_component": "network",
"chunk_index": 987,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "738",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Mise en cache personnalisée dans Azure
API Management
Article • 12/05/2023
Le service Azure API Management prend en charge la mise en cache de réponses HTTP
en utilisant l’URL de la ressource comme clé. La clé peut être modifiée par les en-têtes
de requête à l’aide des propriétés vary-by . Si cette approche permet de mettre en
cache l’ensemble des réponses HTTP (également appelées représentations), elle peut
être aussi parfois utile pour la mise en cache d’une simple partie d’une représentation.
Les stratégies cache-lookup-value et cache-store-value permettent de stocker et de
récupérer des éléments de données arbitraires à partir des définitions de stratégie. Cette
fonctionnalité apporte une valeur supplémentaire à la stratégie send-request,
puisqu’elle vous permet de mettre en cache les réponses à partir de services externes.
Le service Gestion des API utilise un cache de données interne par locataire partagé,
pour vous permettre de continuer à accéder aux mêmes données mises en cache
lorsque vous déployez plusieurs unités. Lorsque vous gérez un déploiement dans
plusieurs régions, chacune des régions comporte cependant des caches indépendants. Il
est important de ne pas se servir du cache comme d’un magasin de données, où il
constitue l’unique source de certains éléments d’informations. Si vous procédez ainsi, et
que vous décidez ensuite de tirer parti du déploiement dans plusieurs régions, les
clients ayant des utilisateurs nomades risquent de perdre l’accès à ces données mises en
cache.
Il peut arriver que, dans les réponses renvoyées, une partie des données soit difficile à
déterminer bien qu’elles restent à jour pendant un laps de temps raisonnable. Pensez,
Architecture
７ Notes
Le cache interne n’est pas disponible dans le niveau Consommation de Gestion des
API Azure. Vous pouvez utiliser un Cache Azure pour Redis externe à la place. | [
-0.013927068561315536,
-0.026788774877786636,
-0.0339907705783844,
-0.002392613096162677,
0.05291806533932686,
0.02551763691008091,
0.03887011483311653,
0.06415359675884247,
-0.06467843055725098,
-0.05086749792098999,
-0.010907464660704136,
-0.04551281780004501,
-0.032055363059043884,
0.01... | {
"azure_component": "network",
"chunk_index": 988,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "739",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
à ces données mises en
cache.
Il peut arriver que, dans les réponses renvoyées, une partie des données soit difficile à
déterminer bien qu’elles restent à jour pendant un laps de temps raisonnable. Pensez,
Architecture
７ Notes
Le cache interne n’est pas disponible dans le niveau Consommation de Gestion des
API Azure. Vous pouvez utiliser un Cache Azure pour Redis externe à la place. Un
cache externe permet un meilleur contrôle du cache et une plus grande flexibilité
pour les instances Gestion des API dans tous les niveaux.
Mise en cache de fragments | [
-0.0052119954489171505,
0.008155406452715397,
-0.018959037959575653,
0.005169320851564407,
0.06329506635665894,
0.018815644085407257,
0.037908993661403656,
0.05329780653119087,
-0.03628768399357796,
-0.047086674720048904,
0.0006323638954199851,
-0.038427140563726425,
-0.03984444960951805,
... | {
"azure_component": "network",
"chunk_index": 989,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "739",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
par exemple, à un service généré par une compagnie aérienne qui fournit des
informations concernant les réservations de vol, l’état du vol, etc. Si l’utilisateur est
membre du programme de points de fidélité de la compagnie aérienne, il obtiendrait
également des informations relatives à l’état actuel de son adhésion et au nombre de
miles cumulé. Ces informations relatives à l’utilisateur peuvent être stockées dans un
autre système, mais il peut être souhaitable de les inclure dans les réponses renvoyées
concernant les réservations et l’état du vol. Cette opération peut être effectuée à l’aide
d’un processus appelé « mise en cache de fragments ». La représentation primaire peut
être renvoyée par le serveur d’origine à l’aide d’un type de jeton pour indiquer
l’emplacement où les informations relatives à l’utilisateur doivent être insérées.
Observez la réponse JSON suivante renvoyée par une API du serveur principal.
JSON
Voici la ressource secondaire disponible à l’emplacement /userprofile/{userid} :
JSON
Pour déterminer les informations utilisateur qu’il convient d’inclure, le service Gestion
des API doit identifier l’utilisateur final. Ce mécanisme dépend de l’implémentation.
L’exemple suivant utilise la revendication Subject d’un jeton JWT.
XML
Le service Gestion des API stocke la valeur enduserid dans une variable contextuelle en
vue d’une utilisation ultérieure. L’étape suivante consiste à déterminer si une demande
précédente a déjà permis d’extraire les informations de l’utilisateur et de les stocker
{
"airline" : "Air Canada",
"flightno" : "871",
"status" : "ontime",
"gate" : "B40",
"terminal" : "2A",
"userprofile" : "$userprofile$"
}
{ "username" : "Bob Smith", "Status" : "Gold" }
<set-variable | [
-0.06785190105438232,
0.021639283746480942,
-0.019790930673480034,
-0.015801507979631424,
0.02858155593276024,
0.026250965893268585,
0.03950617462396622,
0.04304337874054909,
-0.0627339705824852,
-0.05938918516039848,
-0.02595723420381546,
-0.04638389125466347,
-0.06952133774757385,
-0.005... | {
"azure_component": "network",
"chunk_index": 990,
"contains_sku": true,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "740",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
les informations de l’utilisateur et de les stocker
{
"airline" : "Air Canada",
"flightno" : "871",
"status" : "ontime",
"gate" : "B40",
"terminal" : "2A",
"userprofile" : "$userprofile$"
}
{ "username" : "Bob Smith", "Status" : "Gold" }
<set-variable
name="enduserid"
value="@(context.Request.Headers.GetValueOrDefault("Authorization","").Split
(' ')[1].AsJwt()?.Subject)" /> | [
-0.0018295955378562212,
0.03714817017316818,
-0.004667539615184069,
0.0012343570124357939,
0.06427400559186935,
0.013304431922733784,
0.04307160899043083,
0.048367567360401154,
-0.008514579385519028,
-0.057150229811668396,
-0.014792543835937977,
-0.027864566072821617,
-0.05304938182234764,
... | {
"azure_component": "network",
"chunk_index": 991,
"contains_sku": true,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "740",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
dans le cache. Pour ce faire, le service Gestion des API utilise la stratégie cache-lookup-
value.
XML
Si aucune entrée du cache ne correspond à la valeur de clé, aucune variable contextuelle
userprofile n’est créée. Pour vérifier si la recherche a abouti, le service Gestion des API
utilise la stratégie de flux de contrôle choose.
XML
Si la variable contextuelle userprofile n’existe pas, le service Gestion des API doit
exécuter une requête HTTP pour la récupérer.
XML
Le service Gestion des API utilise enduserid pour construire l’URL de la ressource de
profil utilisateur. Une fois la réponse obtenue, le service Gestion des API extrait le texte
du corps de la réponse et le stocke dans une variable contextuelle.
XML
<cache-lookup-value
key="@("userprofile-" + context.Variables["enduserid"])"
variable-name="userprofile" />
<choose>
<when condition="@(!context.Variables.ContainsKey("userprofile"))">
<!-- If the userprofile context variable doesn’t exist, make an HTTP
request to retrieve it. -->
</when>
</choose>
<send-request
mode="new"
response-variable-name="userprofileresponse"
timeout="10"
ignore-error="true">
<!-- Build a URL that points to the profile for the current end-user -->
<set-url>@(new Uri(new
Uri("https://apimairlineapi.azurewebsites.net/UserProfile/"),
(string)context.Variables["enduserid"]).AbsoluteUri)
</set-url>
<set-method>GET</set-method>
</send-request> | [
-0.020732441917061806,
0.02472643181681633,
-0.01217934861779213,
-0.002440238371491432,
0.07293721288442612,
0.017921598628163338,
0.024497829377651215,
0.03910962864756584,
-0.017464911565184593,
-0.08856069296598434,
-0.011717044748365879,
-0.07699668407440186,
-0.02789427898824215,
0.0... | {
"azure_component": "network",
"chunk_index": 992,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "741",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Pour éviter au service Gestion des API d’avoir à réexécuter cette requête HTTP, lorsque
l’utilisateur effectue une autre requête, vous pouvez stocker le profil utilisateur dans le
cache.
XML
Le service Gestion des API stocke la valeur dans le cache en utilisant la même clé que
celle avec laquelle il a initialement tenté de récupérer cette valeur. La durée du stockage
de la valeur doit dépendre de la fréquence à laquelle les informations sont modifiées et
du degré de tolérance des utilisateurs vis-à-vis des informations obsolètes.
Il est important de comprendre que la récupération de données du cache est une
requête réseau hors processus et qu’elle peut potentiellement ajouter des dizaines de
millisecondes à la requête. On peut y voir des avantages lorsqu’il faut plus de temps que
prévu pour déterminer les informations de profil utilisateur si l’on doit exécuter des
requêtes de base de données ou agréger des informations à partir de plusieurs serveurs
principaux.
La dernière étape du processus consiste à mettre à jour la réponse renvoyée avec les
informations de profil utilisateur.
XML
Vous pouvez choisir d’inclure les guillemets dans le jeton afin que même si l’opération
de remplacement ne se produit pas, la réponse renvoyée prenne toujours la forme d’un
script JSON valide.
Une fois que l’on combine ces étapes, on obtient une stratégie semblable à ce qui suit.
<set-variable
name="userprofile"
value="@(((IResponse)context.Variables["userprofileresponse"]).Body.As<strin
g>())" />
<cache-store-value
key="@("userprofile-" + context.Variables["enduserid"])"
value="@((string)context.Variables["userprofile"])" duration="100000" />
<!-- Update response body with user profile-->
<find-and-replace
from='"$userprofile$"'
to="@((string)context.Variables["userprofile"])" /> | [
-0.011372802779078484,
0.008834212087094784,
-0.004458773881196976,
-0.007478820160031319,
0.05487692356109619,
0.03631670027971268,
0.04490659758448601,
0.05746226757764816,
-0.038911495357751846,
-0.05973994359374046,
-0.012772738002240658,
-0.06209944561123848,
-0.05775674432516098,
-0.... | {
"azure_component": "network",
"chunk_index": 993,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "742",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
XML
<policies>
<inbound>
<!-- How you determine user identity is application dependent -->
<set-variable
name="enduserid"
value="@(context.Request.Headers.GetValueOrDefault("Authorization","").Split
(' ')[1].AsJwt()?.Subject)" />
<!--Look for userprofile for this user in the cache -->
<cache-lookup-value
key="@("userprofile-" + context.Variables["enduserid"])"
variable-name="userprofile" />
<!-- If API Management doesn’t find it in the cache, make a request
for it and store it -->
<choose>
<when
condition="@(!context.Variables.ContainsKey("userprofile"))">
<!-- Make HTTP request to get user profile -->
<send-request
mode="new"
response-variable-name="userprofileresponse"
timeout="10"
ignore-error="true">
<!-- Build a URL that points to the profile for the
current end-user -->
<set-url>@(new Uri(new
Uri("https://apimairlineapi.azurewebsites.net/UserProfile/"),
(string)context.Variables["enduserid"]).AbsoluteUri)</set-url>
<set-method>GET</set-method>
</send-request>
<!-- Store response body in context variable -->
<set-variable
name="userprofile"
value="@(((IResponse)context.Variables["userprofileresponse"]).Body.As<strin
g>())" />
<!-- Store result in cache -->
<cache-store-value
key="@("userprofile-" + context.Variables["enduserid"])"
value="@((string)context.Variables["userprofile"])"
duration="100000" />
</when>
</choose>
<base />
</inbound>
<outbound>
<!-- Update response body with user profile--> | [
-0.003646594239398837,
0.006596953608095646,
0.009175465442240238,
-0.018783286213874817,
0.08505208045244217,
-0.009473195299506187,
0.029254501685500145,
-0.026112359017133713,
-0.014636650681495667,
-0.06693152338266373,
0.008026846684515476,
-0.06633647531270981,
-0.050364356487989426,
... | {
"azure_component": "network",
"chunk_index": 994,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "743",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Cette approche de mise en cache est principalement utilisée dans les sites web où le
script HTML est composé côté serveur afin de pouvoir être restitué sur une seule page.
Elle peut également se révéler utile dans les API où les clients ne peuvent pas effectuer
de mise en cache HTTP côté client, ou lorsqu’il est préférable de ne pas confier cette
responsabilité au client.
Ce même type de mise en cache de fragments peut également être effectué sur les
serveurs web principaux qui utilisent un serveur de mise en cache Redis ; il est
cependant utile de s’appuyer sur le service API Management pour exécuter cette
opération lorsque les fragments mis en cache proviennent de serveurs principaux
différents de ceux des réponses principales.
Il n’est pas rare que plusieurs versions différentes d’une implémentation d’une API
soient prises en charge simultanément. Cette prise en charge simultanée permet, par
exemple, de gérer des environnements différents (environnements de développement,
de test, de production, etc.) ou bien de prendre en charge les versions antérieures de
l’API pour laisser aux consommateurs de l’API le temps d’évoluer vers des versions plus
récentes.
Au lieu de demander aux développeurs client de remplacer les URL /v1/customers par
/v2/customers, il est envisageable de stocker dans les données de profil du
consommateur la version de l’API qu’il souhaite actuellement utiliser et d’appeler l’URL
de serveur principal appropriée. Pour déterminer l’URL de serveur principal qu’il
convient d’appeler pour un client spécifique, il est nécessaire d’exécuter une requête
portant sur certaines données de configuration. En mettant en cache ces données de
configuration, le service Gestion des API peut limiter la baisse du niveau de performance
associée à ce processus de recherche.
La première étape consiste à déterminer l’identificateur utilisé pour configurer la version
souhaitée. Dans cet exemple, j’ai choisi | [
-0.04335511848330498,
0.0062243398278951645,
-0.015167794190347195,
-0.024431508034467697,
0.05373818799853325,
0.01515018567442894,
0.0413522869348526,
0.07081559300422668,
-0.06873639672994614,
-0.03392413631081581,
-0.007922637276351452,
-0.012914479710161686,
-0.04211655631661415,
0.00... | {
"azure_component": "network",
"chunk_index": 995,
"contains_sku": true,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "744",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
il est nécessaire d’exécuter une requête
portant sur certaines données de configuration. En mettant en cache ces données de
configuration, le service Gestion des API peut limiter la baisse du niveau de performance
associée à ce processus de recherche.
La première étape consiste à déterminer l’identificateur utilisé pour configurer la version
souhaitée. Dans cet exemple, j’ai choisi d’associer la version à la clé d’abonnement du
produit.
XML
<find-and-replace
from='"$userprofile$"'
to="@((string)context.Variables["userprofile"])" />
<base />
</outbound>
</policies>
Contrôle de version transparent | [
-0.020358651876449585,
0.019788898527622223,
-0.007915452122688293,
-0.03728373348712921,
0.09050706773996353,
0.01574227400124073,
0.04954811930656433,
-0.010402035899460316,
-0.042647965252399445,
-0.05792011693120003,
-0.006772184278815985,
-0.04421200230717659,
-0.07304912805557251,
0.... | {
"azure_component": "network",
"chunk_index": 996,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "744",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Le service Gestion des API effectue alors une recherche dans le cache pour vérifier s’il a
déjà récupéré la version client appropriée.
XML
Ensuite, le service Gestion des API vérifie s’il n’a pas trouvé cette version dans le cache.
XML
S’il n’a pas trouvé la version, le service Gestion des API la récupère.
XML
Extrayez le texte du corps de réponse à partir de la réponse.
XML
Stockez-le de nouveau dans le cache pour une utilisation ultérieure.
XML
<set-variable name="clientid" value="@(context.Subscription.Key)" />
<cache-lookup-value
key="@("clientversion-" + context.Variables["clientid"])"
variable-name="clientversion" />
<choose>
<when condition="@(!context.Variables.ContainsKey("clientversion"))">
<send-request
mode="new"
response-variable-name="clientconfiguresponse"
timeout="10"
ignore-error="true">
<set-url>@(new Uri(new Uri(context.Api.ServiceUrl.ToString() +
"api/ClientConfig/"),(string)context.Variables["clientid"]).AbsoluteUri)
</set-url>
<set-method>GET</set-method>
</send-request>
<set-variable
name="clientversion"
value="@(((IResponse)context.Variables["clientconfiguresponse"]).Body.As<str
ing>())" /> | [
-0.020098460838198662,
-0.00743029685690999,
-0.010614929720759392,
-0.01823032833635807,
0.05734221637248993,
0.011763360351324081,
0.044631585478782654,
0.03264893963932991,
-0.0559208057820797,
-0.060521118342876434,
-0.014100329950451851,
-0.051344964653253555,
-0.036911506205797195,
0... | {
"azure_component": "network",
"chunk_index": 997,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "745",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Pour finir, mettez à jour l’URL du serveur principal pour sélectionner la version du service
souhaitée par le client.
XML
La stratégie complète se présente comme suit :
XML
<cache-store-value
key="@("clientversion-" + context.Variables["clientid"])"
value="@((string)context.Variables["clientversion"])"
duration="100000" />
<set-backend-service
base-url="@(context.Api.ServiceUrl.ToString() + "api/" +
(string)context.Variables["clientversion"] + "/")" />
<inbound>
<base />
<set-variable name="clientid" value="@(context.Subscription.Key)" />
<cache-lookup-value key="@("clientversion-" +
context.Variables["clientid"])" variable-name="clientversion" />
<!-- If API Management doesn’t find it in the cache, make a request for
it and store it -->
<choose>
<when
condition="@(!context.Variables.ContainsKey("clientversion"))">
<send-request mode="new" response-variable-
name="clientconfiguresponse" timeout="10" ignore-error="true">
<set-url>@(new Uri(new Uri(context.Api.ServiceUrl.ToString()
+ "api/ClientConfig/"),(string)context.Variables["clientid"]).AbsoluteUri)
</set-url>
<set-method>GET</set-method>
</send-request>
<!-- Store response body in context variable -->
<set-variable name="clientversion"
value="@(((IResponse)context.Variables["clientconfiguresponse"]).Body.As<str
ing>())" />
<!-- Store result in cache -->
<cache-store-value key="@("clientversion-" +
context.Variables["clientid"])"
value="@((string)context.Variables["clientversion"])" duration="100000" />
</when>
</choose>
<set-backend-service base-url="@(context.Api.ServiceUrl.ToString() +
"api/" + (string)context.Variables["clientversion"] + "/")" />
</inbound> | [
-0.04458233341574669,
-0.009813803248107433,
0.001570813124999404,
-0.034311287105083466,
0.050082530826330185,
0.0248077604919672,
0.04234548285603523,
0.057927053421735764,
-0.033301662653684616,
-0.08353990316390991,
-0.019648874178528786,
-0.036451805382966995,
-0.030694102868437767,
0... | {
"azure_component": "network",
"chunk_index": 998,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "746",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
En permettant aux consommateurs d’API de contrôler en toute transparence la version
du serveur principal utilisée par les clients sans avoir à mettre à jour et redéployer les
clients, nous proposons une solution pratique qui résout de nombreux problèmes liés
au contrôle de version des API.
Dans les déploiements mutualisés plus volumineux, certaines entreprises créent des
groupes de locataires spécifiques sur des déploiements distincts de matériel du serveur
principal. Cette approche contribue à réduire au minimum le nombre de clients affectés
par un problème matériel sur le serveur principal. Elle permet également de déployer de
nouvelles versions de logiciels de manière progressive. Dans l’idéal, cette architecture de
serveur principal doit être transparente pour les consommateurs d’API. Cet objectif est
réalisable en adoptant une approche similaire à celle du contrôle de version transparent,
puisqu’il repose sur la même technique de manipulation de l’URL du serveur principal
qui utilise un état de configuration par clé d’API.
Au lieu de renvoyer une version par défaut de l’API pour chaque clé d’abonnement, vous
devez retourner un identificateur qui associe un locataire au groupe matériel attribué.
Cet identificateur peut être utilisé pour construire l’URL du serveur principal approprié.
L’utilisation du cache du service Azure API Management pour le stockage de n’importe
quel type de données permet d’accéder efficacement aux données de configuration
susceptibles d’affecter le mode de traitement d’une demande entrante. Cette mise en
cache peut également être utilisée pour stocker des fragments de données pouvant
augmenter les réponses retournées à partir d’une API du serveur principal.
Isolation des locataires
Récapitulatif | [
-0.02389887534081936,
-0.017054224386811256,
-0.05260559171438217,
-0.01205110177397728,
0.06019715592265129,
0.023465773090720177,
0.03134369105100632,
0.019776569679379463,
-0.056322239339351654,
-0.06944731622934341,
-0.03740865737199783,
-0.04990968480706215,
-0.06721166521310806,
0.02... | {
"azure_component": "network",
"chunk_index": 999,
"contains_sku": false,
"document_title": "Api_Management",
"file_path": "./azure_docs\\API_Management.pdf",
"is_summary": false,
"service_name": "API Management",
"source": "747",
"source_file": "API_Management.pdf",
"total_pages": 1973
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.