Verbinden Sie das Back-End mit Azure API Management

📅👤mark241⏱️4 Min
GuidesAzureAPI Management
Teilen:

Erfahren Sie, wie Sie mit der ARM Template APIs zur API Management hinzufügen. Verwenden Sie Ressourcen wie operations , policy und das backend , um APIs mit Ihrem Backend zu verbinden. In diesem Artikel wird davon ausgegangen, dass das Back-End in Azure functions implementiert Azure functions .

Definieren Sie die API

Legen Sie zunächst die API-Definition in der API Management . In der API Management wird jede API durch eine Ressource definiert, die als operations .

operations definieren

operations ist eine Ressource, die einer API entspricht. Sie können den API-Pfad und die Parameter hier in dieser Ressource definieren. Werfen wir einen Blick auf die ARM Template für 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}

Beachten Sie, dass dem Namen rev;={apiRevision} angehängt wird, da er als bestimmte Revision bereitgestellt wird, wie in einem anderen Artikel 1 erwähnt. urlTemplate ist in urlTemplate . Variable Parameter werden als {orderId} -Format ausgedrückt. Die Details der Parameter werden in templateParameters . Das obige Beispiel definiert, dass der Typ der orderId string ist. Geben Sie als method die HTTP-Methode an.

Die aus dem obigen Beispiel erstellte GET http(s)://{API Management FQDN}/api/v1/orders/{orderId} . Was wir dieses Mal definiert haben, ist der Teil /orders/{orderId} und der Teil /api/v1 wurde in den vorherigen apis und apiVersionSets 1 definiert. Sie können OpenAPI.yaml importieren, um die API zu definieren. Ich werde das in einem separaten Artikel behandeln.

backends definieren

Als nächstes definieren Sie die 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 sind buchstäblich Ressourcen, die den Backend-Diensten entsprechen, aus denen die API besteht. Dieses Mal übernehmen wir die HTTPTrigger Funktion von Azure functions als Backend. Die URL der Azure functions wird in url , und die Ressource der Azure functions wird durch resourceId . In diesem Fall muss die Route von HTTPTrigger of Azure functions orders/{orderId} .

credentials unter credentials den API-Schlüssel an, mit dem eine Verbindung zu den Azure functions . Das obige Vorlagenbeispiel bedeutet, dass Anmeldeinformationen in Form eines Abfrageparameters wie ?code=xxx werden und die von propertyName angegebene Zeichenfolge festgelegt wird. Der Wert von Anmeldeinformationen liegt in Form einer doppelten Umschließung vor, z. B. {{credential}} . Anmeldeinformationen wie der API-Schlüssel werden in der unten beschriebenen properties gespeichert. Der hier angegebene propertyName ist der Name, der die in den properties gespeicherten Anmeldeinformationen angibt.

Übrigens, um den API-Schlüssel der Azure functions hier anzugeben, müssen Sie den Schlüssel von den Azure functions . Es ist üblich, die Vorlagenfunktionen listSecrets oder listKeys zu verwenden, um Schlüssel in der ARM Template listKeys Für Azure functions v2 2 Azure functions dies jedoch nicht wie erwartet. Es ist besser, es im Voraus mit Azure CLI 3 Azure CLI .

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 verfügen über eine Host- und eine Funktionstaste. In diesem Fall wird der Host-Schlüssel verwendet. Einfach ausgedrückt ist die Funktionstaste eine Taste für jede Funktion, und die Hosttaste ist eine Taste, die mit allen Funktionen verbunden werden kann.

Um APIs mit dem Backend zu verbinden, müssen Sie das Backend auch in der policy angeben.

policy definieren

Legen Sie schließlich eine policy zum Verbinden von Back-End und API-Verwaltung fest. Policy sind eine wichtige Funktion, mit der die API Management um verschiedene Verarbeitungsschritte erweitert werden kann. Hier verwenden wir einen davon, um eine Verbindung zum Backend herzustellen.

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 wird in XML in policyContent . backendPolicy ist in variables definiert, und Sie können sehen, dass die XML-Zeichenfolge definiert ist. Der Punkt ist, dass die Backend-Ressource durch die backend-id angegeben wird. Infolgedessen wird die zuvor erstellte Back-End-Ressource in der policy .

properties definieren

properties ist eine Ressource zum Speichern des in API Management verwendeten Einstellungswerts im Schlüsselwertformat. In diesem Abschnitt verwenden wir diese Ressource, um den API-Schlüssel für die Verbindung mit den Back-End-Azure-Funktionen zu speichern.

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}

Ersetzen Sie displayName durch den Namen der Eigenschaft, die Sie zuvor in den Backends angegeben haben. Geben Sie einen geheimen Wert für value . Geben Sie in diesem Fall den API-Schlüssel der Azure functions die Sie zuvor mit der Azure CLI . tags ist ein Tag, mit dem Sie später nach Eigenschaften suchen können. Geben wir eine beliebige Zeichenkette an. Wenn Sie secret auf true , wird die Eigenschaft verschlüsselt und sicher aufbewahrt.

Bereitstellen

ARM Template wir also die ARM Template auf der Grundlage der bisherigen Erläuterungen bereit.

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}

Jetzt kann die API mithilfe der obigen Vorlage für die Dienstinstanz bereitgestellt werden.

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

Teilen:

Verwandte Artikel