Connectez le backend à Azure API Management

📅👤mark241⏱️4 min
GuidesAzureAPI Management
Partager :

Découvrez comment utiliser le ARM Template pour ajouter des API à la API Management . Utilisez des ressources telles que les operations , la policy et le backend pour connecter les API à votre backend. Dans cet article, nous supposons que le backend est implémenté dans les Azure functions .

Définir l'API

Tout d'abord, définissez la définition de l' API Management dans la API Management . Dans la API Management , chaque API est définie par une ressource appelée operations .

Définir les operations

operations est une ressource correspondant à une API. Vous pouvez définir le chemin et les paramètres de l'API ici dans cette ressource. Jetons un coup d'œil au ARM Template pour les operations .

json
1{
2  "name": "[concat(parameters('serviceName'), '/', parameters('apiName'), ';rev=', parameters('apiRevision'), '/', parameters('operationName'))]",
3  "type": "Microsoft.ApiManagement/service/apis/operations",
4  "apiVersion": "2018-01-01",
5  "dependsOn": [
6    "[resourceId('Microsoft.ApiManagement/service/apis', parameters('serviceName'), concat(parameters('apiName'), ';rev=', parameters('apiRevision')))]",
7    "[resourceId('Microsoft.ApiManagement/service/backends', parameters('serviceName'), parameters('backendName'))]"
8  ],
9  "properties": {
10    "description": "GET Order",
11    "templateParameters": [
12      {
13        "name": "orderId",
14        "type": "string",
15        "values": []
16      }
17    ],
18    "responses": [],
19    "policies": null,
20    "displayName": "GetOrder",
21    "method": "GET",
22    "urlTemplate": "orders/{orderId}"
23  },
24  "resources": []
25}

Notez que le nom est ajouté avec rev;={apiRevision} , car il sera déployé en tant que révision spécifique comme mentionné dans un autre article 1. L'URL est spécifiée dans urlTemplate . Les paramètres variables sont exprimés au format {orderId} . Les détails des paramètres sont décrits dans templateParameters . L'exemple ci-dessus définit que le type de orderId est une chaîne. Pour la method , spécifiez la méthode HTTP.

L'API créée à partir de l'exemple ci-dessus sera GET http(s)://{API Management FQDN}/api/v1/orders/{orderId} . Ce que nous avons défini cette fois, c'est la partie /orders/{orderId} , et la partie /api/v1 été définie dans les apis et apiVersionSets précédents 1. Vous pouvez importer OpenAPI.yaml pour définir l'API. Je couvrirai cela dans un article séparé.

Définir les backends

Ensuite, définissez les backends .

json
1{
2  "name": "[concat(variables('serviceName'), '/', parameters('backendName'))]",
3  "type": "Microsoft.ApiManagement/service/backends",
4  "apiVersion": "2018-01-01",
5  "dependsOn": [
6    "[resourceId('Microsoft.ApiManagement/service/properties', parameters('serviceName'), parameters('propertyName'))]"
7  ],
8  "properties": {
9    "title": null,
10    "description": "Backend of API management",
11    "url": "[concat('https://', parameters('functionsAppName'),'.azurewebsites.net/api')]",
12    "protocol": "http",
13    "credentials": {
14      "query": {
15        "code": ["[concat('{{', parameters('propertyName'), '}}')]"]
16      }
17    },
18    "resourceId": "[concat('https://management.azure.com/subscriptions/', subscription().id, '/resourceGroups/', resourceGroup().name, '/providers/Microsoft.Web/sites/', parameters('functionsAppName'))]"
19  }
20}

backends sont littéralement des ressources équivalentes aux services backend qui composent l'API. Cette fois, nous supposons HTTPTrigger fonction HTTPTrigger fonctions Azure functions est backend. L'url des Azure functions est spécifiée dans url et la ressource des Azure functions est spécifiée par resourceId . Dans ce cas, l'itinéraire de HTTPTrigger des Azure functions doit être orders/{orderId} .

Dans les credentials , spécifiez la clé API pour vous connecter aux Azure functions . L'exemple de modèle ci-dessus signifie que les informations d'identification sont spécifiées sous la forme d'un paramètre de requête tel que ?code=xxx et que la chaîne de caractères spécifiée par propertyName est définie. La valeur des informations d'identification est sous la forme d'un double encadrement, tel que {{credential}} . Les informations d'identification telles que la clé API sont stockées dans la ressource de properties décrite ci-dessous. Le nom de propertyName spécifié ici est le nom qui indique les informations d'identification enregistrées dans les properties .

Soit dit en passant, afin de spécifier la clé API des Azure functions ici, vous devez obtenir la clé à partir des Azure functions . Il est courant d'utiliser les fonctions de modèle listSecrets ou listKeys pour obtenir des clés dans le ARM Template , mais cela ne fonctionne pas comme prévu pour les Azure functions v2 2. Il est préférable de l'obtenir à l'avance à l'aide d' Azure CLI 3.

powershell
1$resourceId = "/subscriptions/$subscriptionid/resourceGroups/$resourceGroup/providers/Microsoft.Web/sites/$functionsAppName"
2$url = "$resourceId/host/default/listKeys?api-version=2016-03-01"
3$ret = az rest --method post --uri $url | ConvertFrom-Json
4$key = $ret.functionKeys.default

Azure functions ont une clé d'hôte et une clé de fonction. Dans ce cas, la clé d'hôte est utilisée. Autrement dit, la touche de fonction est une touche pour chaque fonction, et la touche d'hôte est une touche qui peut être connectée à toutes les fonctions.

Afin de connecter les API au backend, vous devez également spécifier le backend dans la policy .

Définir la policy

Enfin, définissez une policy pour connecter le backend et la gestion des API. Policy est une fonctionnalité importante qui peut ajouter divers traitements à la API Management . Ici, nous utilisons l'un d'eux pour se connecter au backend.

json
1{
2  "variables": {
3    "backendPolicy": "[concat('<policies>\r\n  <inbound>\r\n    <base />\r\n    <set-backend-service id=\"apim-generated-', 'policy','\" backend-id=\"', parameters('backendName'), '\" />\r\n  </inbound>\r\n  <backend>\r\n    <base />\r\n  </backend>\r\n  <outbound>\r\n    <base />\r\n  </outbound>\r\n  <on-error>\r\n    <base />\r\n  </on-error>\r\n</policies>')]"
4  },
5  "resources": [
6    {
7      "name": "[concat(parameters('serviceName'), '/', parameters('apiName'), ';rev=', parameters('apiRevision'), '/', 'policy')]",
8      "type": "Microsoft.ApiManagement/service/apis/policies",
9      "apiVersion": "2018-01-01",
10      "properties": {
11        "policyContent": "[variables('backendPolicy')]",
12        "contentFormat": "xml"
13      }
14    }
15  ]
16}

policy est spécifiée en xml dans policyContent . backendPolicy est défini dans des variables et vous pouvez voir que la chaîne xml est définie. Le fait est que la ressource backend est spécifiée par backend-id . Par conséquent, la ressource principale créée précédemment est spécifiée dans la policy .

Définir les properties

properties est une ressource pour enregistrer la valeur de paramètre utilisée dans la API Management au format clé-valeur. Ici, nous utiliserons cette ressource pour conserver la clé API pour se connecter aux fonctions backend azure.

json
1{
2  "type": "Microsoft.ApiManagement/service/properties",
3  "name": "[concat(parameters('serviceName'), '/', parameters('propertyName'))]",
4  "apiVersion": "2018-06-01-preview",
5  "scale": null,
6  "properties": {
7    "displayName": "[parameters('propertyName')]",
8    "value": "[parameters('functionHostKey')]",
9    "tags": ["key", "function"],
10    "secret": true
11  }
12}

Remplacez displayName par le nom de la propriété que vous avez spécifiée précédemment dans les backends. Spécifiez une valeur secrète pour value . Dans ce cas, spécifiez la clé API des Azure functions obtenues précédemment avec Azure CLI . tags est une balise à utiliser lors de la recherche de propriétés ultérieurement. Spécifions une chaîne de caractères arbitraire. En définissant secret sur true , la propriété sera cryptée et sécurisée.

Déployer

Déployons donc le ARM Template sur la base de ce que nous avons expliqué jusqu'à présent.

json
1{
2  "$schema": "https://schema.management.azure.com/schemas/2018-05-01/deploymentTemplate.json#",
3  "contentVersion": "1.0.0.0",
4  "parameters": {
5    "serviceName": {
6      "type": "string",
7      "metadata": {
8        "description": "Service Name"
9      }
10    },
11    "apiName": {
12      "type": "string",
13      "metadata": {
14        "description": "API Name"
15      }
16    },
17    "apiRevision": {
18      "type": "string",
19      "metadata": {
20        "description": "API Revision"
21      }
22    },
23    "operationName": {
24      "type": "string",
25      "metadata": {
26        "description": "Operation name"
27      }
28    },
29    "backendName": {
30      "type": "string",
31      "metadata": {
32        "description": "Backend Name"
33      }
34    },
35    "functionHostKey": {
36      "type": "securestring",
37      "metadata": {
38        "description": "Host key for the functions app"
39      }
40    },
41    "functionAppName": {
42      "type": "string",
43      "metadata": {
44        "description": "Functions App Name"
45      }
46    },
47    "propertyName": {
48      "type": "string",
49      "metadata": {
50        "description": "Property Name"
51      }
52    }
53  },
54  "variables": {
55    "backendPolicy": "[concat('<policies>\r\n  <inbound>\r\n    <base />\r\n    <set-backend-service id=\"apim-generated-', 'policy','\" backend-id=\"', parameters('backendName'), '\" />\r\n  </inbound>\r\n  <backend>\r\n    <base />\r\n  </backend>\r\n  <outbound>\r\n    <base />\r\n  </outbound>\r\n  <on-error>\r\n    <base />\r\n  </on-error>\r\n</policies>')]"
56  },
57  "resources": [
58    {
59      "name": "[concat(parameters('serviceName'), '/', parameters('apiName'), ';rev=', parameters('apiRevision'), '/', parameters('operationName'))]",
60      "type": "Microsoft.ApiManagement/service/apis/operations",
61      "apiVersion": "2019-01-01",
62      "dependsOn": [
63        "[resourceId('Microsoft.ApiManagement/service/backends', parameters('serviceName'), parameters('backendName'))]"
64      ],
65      "properties": {
66        "description": "GET Order",
67        "templateParameters": [
68          {
69            "name": "orderId",
70            "type": "string",
71            "values": []
72          }
73        ],
74        "responses": [],
75        "policies": null,
76        "displayName": "GetOrder",
77        "method": "GET",
78        "urlTemplate": "orders/{orderId}"
79      },
80      "resources": []
81    },
82    {
83      "name": "[concat(parameters('serviceName'), '/', parameters('apiName'), ';rev=', parameters('apiRevision'), '/', 'policy')]",
84      "type": "Microsoft.ApiManagement/service/apis/policies",
85      "apiVersion": "2018-01-01",
86      "properties": {
87        "policyContent": "[variables('backendPolicy')]",
88        "contentFormat": "xml"
89      }
90    },
91    {
92      "name": "[concat(parameters('serviceName'), '/', parameters('backendName'))]",
93      "type": "Microsoft.ApiManagement/service/backends",
94      "apiVersion": "2018-01-01",
95      "dependsOn": [
96        "[resourceId('Microsoft.ApiManagement/service/properties', parameters('serviceName'), parameters('propertyName'))]"
97      ],
98      "properties": {
99        "title": null,
100        "description": "Backend of API management",
101        "url": "[concat('https://', parameters('functionAppName'),'.azurewebsites.net/api')]",
102        "protocol": "http",
103        "credentials": {
104          "query": {
105            "code": ["[concat('{{', parameters('propertyName'), '}}')]"]
106          }
107        },
108        "resourceId": "[concat('https://management.azure.com/subscriptions/', subscription().id, '/resourceGroups/', resourceGroup().name, '/providers/Microsoft.Web/sites/', parameters('functionAppName'))]"
109      }
110    },
111    {
112      "type": "Microsoft.ApiManagement/service/properties",
113      "name": "[concat(parameters('serviceName'), '/', parameters('propertyName'))]",
114      "apiVersion": "2018-06-01-preview",
115      "scale": null,
116      "properties": {
117        "displayName": "[parameters('propertyName')]",
118        "value": "[parameters('functionHostKey')]",
119        "tags": ["key", "function"],
120        "secret": true
121      }
122    }
123  ]
124}

L'API peut désormais être déployée sur l'instance de service à l'aide du modèle ci-dessus.

Footnotes

  1. Set version and revision with Azure API Management ↩ ↩2

  2. Changes to Key Management in Functions V2 ↩

  3. Managing Azure Functions Keys (using the new ARM APIs!) ↩

Partager :

Articles connexes