Backend verbinden met Azure API Management

📅👤mark241⏱️4 min
GuidesAzureAPI Management
Delen:

Meer informatie over het gebruik van de ARM Template om API's toe te voegen aan API Management . Gebruik bronnen zoals operations , policy en backend om API's te verbinden met uw backend. In dit artikel gaan we ervan uit dat de backend is geïmplementeerd in Azure functions .

Definieer de API

Stel eerst de API-definitie in API Management . In API Management wordt elke API gedefinieerd door een resource die operations .

Definieer operations

operations is een resource die overeenkomt met één API. U kunt het API-pad en de parameters hier in deze bron definiëren. Laten we de ARM Template voor 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}

Merk op dat de naam wordt toegevoegd met rev;={apiRevision} , omdat deze zal worden geïmplementeerd als een specifieke revisie zoals vermeld in ander artikel 1. URL is opgegeven in urlTemplate . Variabele parameters worden uitgedrukt als {orderId} -formaat. De details van de parameters worden beschreven in templateParameters . In het bovenstaande voorbeeld wordt gedefinieerd dat het type orderId string is. Geef voor method de HTTP-methode op.

De API gemaakt op basis van het bovenstaande voorbeeld is GET http(s)://{API Management FQDN}/api/v1/orders/{orderId} . Wat we deze keer hebben gedefinieerd, is het gedeelte /orders/{orderId} en het gedeelte /api/v1 is gedefinieerd in de vorige apis en apiVersionSets 1. U kunt OpenAPI.yaml importeren om API te definiëren. Ik zal dat in een apart artikel bespreken.

Definieer backends

Definieer vervolgens de 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 zijn letterlijk bronnen die gelijkwaardig zijn aan de backend-services waaruit de API bestaat. Deze keer nemen we de HTTPTrigger functie van Azure functions als backend. De url van de Azure functions is gespecificeerd in url en de resource van de Azure functions is gespecificeerd door resourceId . In dit geval moet de route van HTTPTrigger van Azure functions orders/{orderId} .

Geef bij credentials de API-sleutel op om verbinding te maken met de Azure functions . Het bovenstaande voorbeeld van de sjabloon betekent dat referenties worden opgegeven in de vorm van een query-parameter zoals ?code=xxx en dat de tekenreeks die is opgegeven door propertyName is ingesteld. De waarde van de inloggegevens is in de vorm van dubbele bijlagen, zoals {{credential}} . Referenties zoals API Key worden opgeslagen in de properties die hieronder wordt beschreven. De hier opgegeven propertyName is de naam die de referenties aangeeft die zijn opgeslagen in properties .

Trouwens, om de API Key van de Azure functions hier op te geven, moet je de Key van de Azure functions . Het is gebruikelijk om de sjabloonfuncties listSecrets of listKeys te gebruiken om sleutels in ARM Template , maar het werkt niet zoals verwacht voor Azure functions v2 2. Het is beter om het vooraf te krijgen met behulp van 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 hebben een host-toets en een functietoets. In dit geval wordt de hostsleutel gebruikt. Simpel gezegd, de functietoets is een toets voor elke functie en de host-toets is een toets die op alle functies kan worden aangesloten.

Om API's met de backend te verbinden, moet u ook de backend in het policy opgeven.

Bepaal policy

Stel ten slotte een policy in om backend en API Management te verbinden. Policy is een belangrijke functie die verschillende verwerkingen kan toevoegen aan API Management . Hier gebruiken we een van hen om verbinding te maken met de 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 is gespecificeerd in xml in policyContent . backendPolicy is gedefinieerd in variables en u kunt zien dat de xml-string is gedefinieerd. Het punt is dat de backend-resource wordt gespecificeerd door backend-id . Als gevolg hiervan wordt de eerder gemaakte back-endbron in het policy gespecificeerd.

Definieer properties

properties is een hulpmiddel om de in API Management gebruikte instellingswaarde op te slaan in sleutel / waarde-indeling. Hier zullen we deze bron gebruiken om de API Key vast te houden om verbinding te maken met de azuurblauwe backend-functies.

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}

Vervang displayName door de naam van de eigenschap die u eerder in backends hebt opgegeven. Geef een geheime waarde op voor value . In dit geval geeft u de API-sleutel op van de Azure functions die u eerder met de Azure CLI . tags is een tag om later te zoeken naar eigenschappen. Laten we een willekeurige tekenreeks opgeven. Door secret te stellen op true , wordt de eigenschap gecodeerd en beveiligd.

Inzetten

Laten we de ARM Template basis van wat we tot nu toe hebben uitgelegd.

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}

Nu kan API worden geïmplementeerd in de service-instantie met behulp van de bovenstaande sjabloon.

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!) ↩

Delen:

Gerelateerde artikelen

Beschrijf Azure-resources als ARM Template
Guides

Beschrijf Azure-resources als ARM Template

ARM Template is een json-bestand dat Azure-resources definieert. Leer hoe u efficiënt ARM Templates kunt maken.

mark241