Conectar back-end ao Gerenciamento de API do Azure

📅👤mark241⏱️4 min
GuidesAzureAPI Management
Compartilhar:

Aprenda a usar o ARM Template para adicionar APIs ao API Management . Use recursos como operations , policy e backend - backend para conectar APIs ao seu back-end. Neste artigo, presumimos que o back-end seja implementado nas Azure functions .

Defina a API

Primeiro, defina a definição da API Management no API Management . No API Management , cada API é definida por um recurso chamado operations .

Definir operations

operations é um recurso correspondente a uma API. Você pode definir o caminho e os parâmetros da API aqui neste recurso. Vamos dar uma olhada no modelo do ARM Template para 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}

Observe que o nome é anexado com rev;={apiRevision} , pois será implantado como uma revisão específica, conforme mencionado em outro artigo 1. Url é especificado em urlTemplate . Os parâmetros variáveis são expressos no formato {orderId} . Os detalhes dos parâmetros são descritos em templateParameters . O exemplo acima define que o tipo de orderId é string. Para o method , especifique o método HTTP.

A API criada a partir do exemplo acima será GET http(s)://{API Management FQDN}/api/v1/orders/{orderId} . O que definimos neste momento é a parte /orders/{orderId} , e a parte /api/v1 foi definida nas apis e apiVersionSets anteriores 1. Você pode importar o OpenAPI.yaml para definir a API. Vou cobrir isso em um artigo separado.

Definir backends

Em seguida, defina os backends - 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 end são literalmente recursos equivalentes aos serviços de back-end que compõem a API. Desta vez, assumimos a função HTTPTrigger funções do Azure functions como back-end. O URL das Azure functions do Azure functions é especificado em url , e o recurso das Azure functions do Azure functions é especificado por resourceId . Nesse caso, a rota do HTTPTrigger das Azure functions do Azure functions deve ser orders/{orderId} .

Nas credentials , especifique a Chave da API para conectar-se às Azure functions do Azure functions . O exemplo de modelo acima significa que as credenciais são especificadas na forma de um parâmetro de consulta, como ?code=xxx , e a cadeia de caracteres especificada por propertyName é definida. O valor das credenciais está na forma de anexo duplo, como {{credential}} . Credenciais como API Key são armazenadas no recurso de properties descrito abaixo. O propertyName especificado aqui é o nome que indica as credenciais salvas nas properties .

A propósito, para especificar aqui a Chave da API das Azure functions do Azure functions , você precisa obter a Chave nas Azure functions do Azure functions . É comum usar as funções de modelo listSecrets ou listKeys para obter chaves no ARM Template , mas não funciona conforme o esperado para as Azure functions v2 2. É melhor obtê-lo com antecedência usando a 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 têm uma chave de host e uma tecla de função. Nesse caso, a chave do host é usada. Simplificando, a tecla de função é uma tecla para cada função, e a tecla host é uma tecla que pode ser conectada a todas as funções.

Para conectar APIs ao back-end, você também precisa especificar o back-end na policy .

Definir policy

Por fim, defina uma policy para conectar o backend e o gerenciamento de API. Policy é um recurso importante que pode adicionar vários processos ao API Management . Aqui usamos um deles para conectar-se ao back-end.

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 é especificada em xml em policyContent . backendPolicy é definido em variables e você pode ver que a sequência xml está definida. O ponto é que o recurso de backend-id é especificado por backend-id . Como resultado, o recurso de back-end criado anteriormente é especificado na policy .

Definir properties

properties é um recurso para salvar o valor da configuração usado no API Management no formato de valor-chave. Aqui, usaremos esse recurso para manter a chave da API conectada às funções do 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}

Substitua displayName pelo nome da propriedade que você especificou anteriormente nos back-ends. Especifique um valor secreto para o value . Nesse caso, especifique a chave de API das Azure functions do Azure functions obtidas anteriormente com a Azure CLI do Azure CLI . tags é uma marca a ser usada ao procurar propriedades posteriormente. Vamos especificar uma cadeia de caracteres arbitrária. Ao definir secret como true , a propriedade será criptografada e mantida em segurança.

Implantar

Então, vamos implantar o ARM Template base no que explicamos até agora.

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}

Agora a API pode ser implantada na instância de serviço usando o modelo acima.

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

Compartilhar:

Artigos relacionados