Connetti back-end alla gestione API di Azure

📅👤mark241⏱️4 min
GuidesAzureAPI Management
Condividi:

Scopri come utilizzare il ARM Template per aggiungere API alla API Management . Utilizza risorse come operations , policy e backend - backend per connettere le API al tuo back-end. In questo articolo supponiamo che il back-end sia implementato nelle Azure functions .

Definire l'API

Innanzitutto, imposta la definizione API Management . In API Management , ogni API è definita da una risorsa chiamata operations .

Definire le operations

operations è una risorsa corrispondente a un'API. È possibile definire il percorso API e i parametri qui in questa risorsa. Diamo un'occhiata al ARM Template per le 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}

Si noti che il nome viene aggiunto con rev;={apiRevision} , poiché verrà distribuito come una revisione specifica come menzionato nell'altro articolo 1. L'URL è specificato in urlTemplate . I parametri delle variabili sono espressi nel formato {orderId} . I dettagli dei parametri sono descritti in templateParameters . L'esempio precedente definisce che il tipo di orderId è stringa. Per il method , specificare il metodo HTTP.

L'API creata dall'esempio sopra sarà GET http(s)://{API Management FQDN}/api/v1/orders/{orderId} . Quello che abbiamo definito questa volta è l' /orders/{orderId} parte, e la /api/v1 parte è stato definito nelle precedenti apis e apiVersionSets 1. È possibile importare OpenAPI.yaml per definire l'API. Tratterò questo in un articolo separato.

Definire i backends

Quindi, definire i 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 sono letteralmente risorse che sono equivalenti ai servizi back-end che compongono l'API. Questa volta, assumiamo la funzione HTTPTrigger funzioni di Azure functions come back-end. L'URL delle Azure functions è specificato url e la risorsa delle Azure functions è specificata da resourceId . In questo caso, il percorso di HTTPTrigger delle Azure functions di Azure functions deve essere orders/{orderId} .

Nelle credentials , specificare la chiave API per connettersi con le Azure functions . L'esempio di modello sopra riportato indica che le credenziali sono specificate sotto forma di un parametro di query come ?code=xxx e che è impostata la stringa di caratteri specificata da propertyName . Il valore delle credenziali ha la forma di un doppio allegato, come {{credential}} . Le credenziali come la chiave API sono archiviate nella risorsa delle properties descritta di seguito. Il nome propertyName specificato qui è il nome che indica le credenziali salvate nelle properties .

A proposito, per specificare qui la chiave API delle Azure functions , è necessario ottenere la chiave dalle Azure functions . È comune usare l' listSecrets funzioni dei modelli listSecrets o listKeys per ottenere le chiavi nel ARM Template , ma non funziona come previsto per le Azure functions v2 2. È meglio ottenerlo in anticipo usando l' 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 hanno una chiave host e una chiave funzione. In questo caso, viene utilizzata la chiave host. In poche parole, il tasto funzione è un tasto per ogni funzione e il tasto host è un tasto che può essere collegato a tutte le funzioni.

Per connettere le API al back-end, è necessario specificare anche il back-end nella policy .

Definire la policy

Infine, imposta un policy per connettere backend e gestione API. Policy è una funzione importante che può aggiungere varie elaborazioni alla API Management . Qui ne usiamo uno per connetterci al 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 è specificato in xml in policyContent . backendPolicy è definito in variables e puoi vedere che la stringa xml è definita. Il punto è che la risorsa backend-id è specificata da backend-id . Di conseguenza, la risorsa back-end creata in precedenza è specificata nella policy .

Definire le properties

properties è una risorsa per salvare il valore di impostazione utilizzato in API Management in formato valore-chiave. Qui, useremo questa risorsa per contenere la chiave API per connetterci alle funzioni azzurro del back-end.

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}

Sostituisci displayName con il nome della proprietà specificata in precedenza nei back-end. Specificare un valore segreto per value . In questo caso, specificare la chiave API delle Azure functions ottenute in precedenza con l' Azure CLI . tags è un tag da utilizzare per la ricerca di proprietà in un secondo momento. Specifichiamo una stringa di caratteri arbitraria. Impostando secret su true , la proprietà verrà crittografata e mantenuta sicura.

Deploy

Quindi, implementiamo il ARM Template base a ciò che abbiamo spiegato finora.

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}

Ora l'API può essere distribuita all'istanza del servizio utilizzando il modello sopra.

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

Condividi:

Articoli correlati