Tutorial: Crie uma API Calc REST com duas integrações AWS de serviços e uma integração Lambda sem proxy - Amazon API Gateway

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Tutorial: Crie uma API Calc REST com duas integrações AWS de serviços e uma integração Lambda sem proxy

O tutorial Conceitos básicos da integração não proxy usa a integração Lambda Function exclusivamente. A integração Lambda Function é um caso especial do tipo de integração do AWS Service que executa grande parte da configuração de integração para você, como adicionar automaticamente as permissões necessárias com base em recursos para invocar a função do Lambda. Aqui, duas das três integrações usam a integração AWS Service Nesse tipo de integração, você tem mais controle, mas precisará executar tarefas manualmente, como criar e especificar uma função do IAM que contém as permissões adequadas.

Neste tutorial, você criará uma função do Lambda Calc que implementa operações aritméticas básicas, aceitando e retornando a entrada e a saída formatadas em JSON. Você vai criar uma API REST e integrá-la à função do Lambda das seguintes formas:

  1. Ao expor um método GET no recurso /calc para invocar a função do Lambda, fornecendo a entrada como parâmetros de string de consulta. (Integração AWS Service)

  2. Ao expor um método POST no recurso /calc para invocar a função do Lambda, fornecendo a entrada na carga de solicitação do método. (Integração AWS Service)

  3. Ao expor um GET em recursos /calc/{operand1}/{operand2}/{operator} aninhados para invocar a função do Lambda, fornecendo a entrada como parâmetros de caminho. (Integração Lambda Function)

Além de experimentar este tutorial, talvez você queira estudar o arquivo de definição do OpenAPI para a API Calc, que pode ser importado para o API Gateway seguindo as instruções em Configurar uma API REST usando OpenAPI.

Criar uma função do IAM que pode ser assumida

Para que sua API invoque sua função do Lambda Calc, você precisará ter uma função do IAM do API Gateway que pode ser assumida, que é uma função do IAM com o seguinte relacionamento confiável:

{ "Version": "2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": "apigateway.amazonaws.com" }, "Action": "sts:AssumeRole" } ] }

A função que você criar precisará ter a permissão do Lambda InvokeFunction. Caso contrário, o autor da chamada de API receberá uma resposta 500 Internal Server Error. Para conceder essa permissão à função, você anexará a política do IAM a ela:

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "lambda:InvokeFunction", "Resource": "*" } ] }

Veja a seguir como fazer isso:

Criar uma função do IAM do API Gateway que possa ser assumida
  1. Faça login no console do IAM.

  2. Escolha Roles.

  3. Selecione Create Role.

  4. Em Select type of trusted entity (Selecionar tipo de entidade confiável), selecione AWS Serviço.

  5. Em Choose the service that will use this role (Escolha o serviço que usará essa função), escolha Lambda.

  6. Escolha Next: Permissions (Próximo: Permissões).

  7. Selecione Create Policy (Criar política).

    Uma nova janela do console Create Policy (Criar Política) será aberta. Nessa janela, faça o seguinte:

    1. Na guia JSON, substitua a política existente pela política a seguir:

      { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "lambda:InvokeFunction", "Resource": "*" } ] }
    2. Escolha Review policy (Revisar política).

    3. Em Review Policy (Revisar política), faça o seguinte:

      1. Em Name, digite um nome de usuário, como lambda_execute.

      2. Selecione Create Policy (Criar política).

  8. Na janela do console Create Role (Criar função) original, faça o seguinte:

    1. Em Attach permissions policies (Anexar permissões políticas), escolha a política lambda_execute na lista suspensa.

      Se você não vir a política na lista, selecione o botão Atualizar na parte superior da lista. (Não atualize a página do navegador.)

    2. Selecione Next: Tags (Próximo: tags).

    3. Selecione Next:Review (Próximo: análise).

    4. Em Role name (Nome da função), digite um nome como lambda_invoke_function_assume_apigw_role.

    5. Selecione Create role.

  9. Escolha lambda_invoke_function_assume_apigw_role na lista de funções.

  10. Selecione a guia Trust relationships (Relações de confiança).

  11. Escolha Edit trust relationship (Editar relação de confiança).

  12. Substitua a política existente pela seguinte:

    { "Version": "2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": [ "lambda.amazonaws.com", "apigateway.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] }
  13. Escolha Update Trust Policy.

  14. Anote o ARN da função para a função que acabou de criar. Você precisará disso mais tarde.

Criar uma função do Lambda Calc

Depois, você criará uma função do Lambda usando o console do Lambda.

  1. No console do Lambda, escolha Create function (Criar função).

  2. Escolha Author from Scratch.

  3. Em Name (Nome), insira Calc.

  4. Em Tempo de execução, escolha o último runtime Node.js ou Python compatível.

  5. Escolha a opção Criar função.

  6. Copie a função do Lambda a seguir em seu runtime preferido e cole-a no editor de código do console do Lambda.

    Node.js
    export const handler = async function (event, context) { console.log("Received event:", JSON.stringify(event)); if ( event.a === undefined || event.b === undefined || event.op === undefined ) { return "400 Invalid Input"; } const res = {}; res.a = Number(event.a); res.b = Number(event.b); res.op = event.op; if (isNaN(event.a) || isNaN(event.b)) { return "400 Invalid Operand"; } switch (event.op) { case "+": case "add": res.c = res.a + res.b; break; case "-": case "sub": res.c = res.a - res.b; break; case "*": case "mul": res.c = res.a * res.b; break; case "/": case "div": if (res.b == 0) { return "400 Divide by Zero"; } else { res.c = res.a / res.b; } break; default: return "400 Invalid Operator"; } return res; };
    Python
    import json def lambda_handler(event, context): print(event) try: (event['a']) and (event['b']) and (event['op']) except KeyError: return '400 Invalid Input' try: res = { "a": float( event['a']), "b": float( event['b']), "op": event['op']} except ValueError: return '400 Invalid Operand' if event['op'] == '+': res['c'] = res['a'] + res['b'] elif event['op'] == '-': res['c'] = res['a'] - res['b'] elif event['op'] == '*': res['c'] = res['a'] * res['b'] elif event['op'] == '/': if res['b'] == 0: return '400 Divide by Zero' else: res['c'] = res['a'] / res['b'] else: return '400 Invalid Operator' return res
  7. Em Execution role (Função de execução), selecione Choose an existing role (Selecionar uma função existente).

  8. Insira o ARN da função para a função lambda_invoke_function_assume_apigw_role que você criou anteriormente.

  9. Escolha Deploy (Implantar).

Essa função requer dois operandos (a e b) e um operador (op) a partir do parâmetro de entrada event. A entrada é um objeto JSON no seguinte formato:

{ "a": "Number" | "String", "b": "Number" | "String", "op": "String" }

Essa função retorna o resultado calculado (c) e a entrada. Para uma entrada inválida, a função retorna o valor nulo ou a string "Invalid op" como resultado. A saída é do seguinte formato JSON:

{ "a": "Number", "b": "Number", "op": "String", "c": "Number" | "String" }

É necessário testar a função no console do Lambda antes de integrá-la à API na próxima etapa.

Testar a função do Lambda Calc

Veja a seguir como testar a função Calc no console do Lambda:

  1. Selecione a guia Testar.

  2. Para o nome de evento de teste, insira calc2plus5.

  3. Substitua a definição de eventos de teste pelo seguinte:

    { "a": "2", "b": "5", "op": "+" }
  4. Escolha Save (Salvar).

  5. Escolha Test (Testar).

  6. Expanda Execution result: succeeded (Resultado da execução: com êxito). Você deve ver o seguinte:

    { "a": 2, "b": 5, "op": "+", "c": 7 }

Criar uma API Calc

O procedimento a seguir mostra como criar uma API para a função do Lambda Calc que você acabou de criar. Nas seções a seguir, você adicionará recursos e métodos a ela.

Como criar uma API
  1. Inicie uma sessão no console do API Gateway em https://console.aws.amazon.com/apigateway.

  2. Se esta for a primeira vez que você usa o API Gateway, você verá uma página com os recursos do serviço. Em REST API, escolha Build (Criar). Quando o pop-up Create Example API (Criar API de exemplo) for exibido, escolha OK.

    Se essa não for a primeira vez que você usa o API Gateway, escolha Create API (Criar API). Em REST API, escolha Build (Criar).

  3. Em API name (Nome da API), insira LambdaCalc.

  4. (Opcional) Em Description (Descrição), insira uma descrição.

  5. Mantenha Tipo de endpoint da API definido como Regional.

  6. Selecione Create API (Criar API).

Integração 1: Criar um método GET com parâmetros de consulta para chamar a função do Lambda

Ao criar um método GET que transmita parâmetros de string de consulta para a função do Lambda, habilite a API para ser invocada de um navegador. Essa abordagem pode ser útil, especialmente para APIs que permitem acesso aberto.

Depois de criar uma API, você criará um recurso. Normalmente, os recursos da API são organizados em uma árvore de recursos, de acordo com a lógica do aplicativo. Para esta etapa, você vai criar um recurso /calc.

Como criar um recurso /calc
  1. Selecione Criar recurso.

  2. Mantenha Recurso proxy desativado.

  3. Mantenha Caminho do recurso como /.

  4. Em Resource Name (Nome do recurso), insira calc.

  5. Mantenha CORS (Compartilhamento de recursos de origem cruzada) desativado.

  6. Selecione Criar recurso.

Ao criar um método GET que transmita parâmetros de string de consulta para a função do Lambda, habilite a API para ser invocada de um navegador. Essa abordagem pode ser útil, especialmente para APIs que permitem acesso aberto.

Neste método, o Lambda requer que a solicitação POST seja usada para invocar qualquer função do Lambda. Esse exemplo mostra que o método HTTP em uma solicitação de método de front-end pode ser diferente da solicitação de integração no backend.

Como criar um método GET
  1. Selecione o recurso /calc e Criar método.

  2. Em Tipo de método, selecione GET.

  3. Em Tipo de integração, selecione AWS service (Serviço da AWS).

  4. Para Região da AWS, selecione o Região da AWS local em que você criou sua função Lambda.

  5. Em AWS service (Serviço da AWS), selecione Lambda.

  6. Mantenha o subdomínio da AWS em branco.

  7. Em Método HTTP, selecione POST.

  8. Em Tipo de ação, escolha Usar substituição de caminho. Essa opção nos permite especificar o ARN da ação Invoke para executar nossa função Calc.

  9. Em Substituição de caminho, digite 2015-03-31/functions/arn:aws:lambda:us-east-2:account-id:function:Calc/invocations. Para account-id, insira seu Conta da AWS ID. Paraus-east-2, insira o Região da AWS local em que você criou sua função Lambda.

  10. Em Perfil de execução, digite o ARN do perfil para lambda_invoke_function_assume_apigw_role.

  11. Não altere as configurações do Cache de credenciais e do Tempo limite padrão.

  12. Escolha Criar método.

Agora você configurará parâmetros de consulta para o método GET no recurso /calc para que ele possa receber a entrada em nome da função do Lambda de back-end.

Como configurar parâmetros de string de consulta
  1. Na guia Solicitação de método, em Configuração de solicitação de método, escolha Editar.

  2. Em Validador de solicitação, selecione Validar parâmetros de string de consulta e cabeçalhos. Essa configuração fará com que uma mensagem de erro seja gerada se o cliente não especificar os parâmetros necessários.

  3. Selecione Parâmetros de string de consulta de URL e faça o seguinte:

    1. Escolha Add query string (Adicionar string de consulta).

    2. Em Nome, digite operand1.

    3. Ative a opção Obrigatório.

    4. Mantenha Armazenamento em cache desativado.

    Repita as mesmas etapas e crie uma string de consulta chamada operand2 e uma string de consulta chamada operator.

  4. Escolha Salvar.

Agora, você vai criar um modelo de mapeamento para converter as strings de consulta fornecidas pelo cliente na carga útil de solicitações de integração, conforme exigido pela função Calc. Esse modelo associa os três parâmetros de consulta declarados em Solicitação de método a valores de propriedade designados do objeto JSON como entrada para a função do Lambda de back-end. O objeto JSON transformado será incluído como a carga útil da solicitação de integração.

Como associar parâmetros de entrada à solicitação de integração
  1. Na guia Solicitação de integração, em Configurações de solicitação de integração, selecione Editar.

  2. Em Passagem do corpo da solicitação, selecione Quando não há modelos definidos (recomendado).

  3. Selecione Modelos de mapeamento.

  4. Escolha Add mapping template (Adicionar modelo de mapeamento).

  5. Em Tipo de conteúdo, insira application/json.

  6. Em Corpo do modelo, insira o seguinte código:

    { "a": "$input.params('operand1')", "b": "$input.params('operand2')", "op": "$input.params('operator')" }
  7. Escolha Salvar.

Agora, é possível testar o método GET para verificar se ele foi configurado corretamente para invocar a função do Lambda:

Como testar o método GET
  1. Selecione a guia Testar. Talvez seja necessário selecionar o botão de seta para a direita para mostrar a guia.

  2. Em Strings de consulta, digite operand1=2&operand2=3&operator=+.

  3. Escolha Test (Testar).

    Os resultados devem ser semelhantes ao seguinte:

    
                      Criar uma API no API Gateway como um proxy do Lambda

Integração 2: Criar um método POST com uma carga JSON para chamar a função do Lambda

Depois da criação de um método POST com uma carga JSON para chamar a função do Lambda, o cliente deve enviar a entrada necessária para a função de backend no corpo da solicitação. Para garantir que o cliente faça upload dos dados de entrada corretos, você habilitará a validação de solicitações na carga.

Como criar um método POST com uma carga útil do JSON
  1. Selecione o recurso /calc e Criar método.

  2. Em Tipo de método, selecione POST.

  3. Em Tipo de integração, selecione AWS service (Serviço da AWS).

  4. Para Região da AWS, selecione o Região da AWS local em que você criou sua função Lambda.

  5. Em AWS service (Serviço da AWS), selecione Lambda.

  6. Mantenha o subdomínio da AWS em branco.

  7. Em Método HTTP, selecione POST.

  8. Em Tipo de ação, escolha Usar substituição de caminho. Essa opção nos permite especificar o ARN da ação Invoke para executar nossa função Calc.

  9. Em Substituição de caminho, digite 2015-03-31/functions/arn:aws:lambda:us-east-2:account-id:function:Calc/invocations. Para account-id, insira seu Conta da AWS ID. Paraus-east-2, insira o Região da AWS local em que você criou sua função Lambda.

  10. Em Perfil de execução, digite o ARN do perfil para lambda_invoke_function_assume_apigw_role.

  11. Não altere as configurações do Cache de credenciais e do Tempo limite padrão.

  12. Escolha Criar método.

Agora você vai criar um modelo de entrada para descrever a estrutura de dados de entrada e validar o corpo da solicitação recebida.

Como criar o modelo de entrada
  1. No painel de navegação principal, selecione Modelos.

  2. Escolha Criar modelo.

  3. Em Nome, digite input.

  4. Em Tipo de conteúdo, insira application/json.

    Se nenhum tipo de conteúdo correspondente for encontrado, a validação da solicitação não será executada. Para usar o mesmo modelo, independentemente do tipo de conteúdo, insira $default.

  5. Em Esquema do modelo, insira o seguinte modelo:

    { "type":"object", "properties":{ "a":{"type":"number"}, "b":{"type":"number"}, "op":{"type":"string"} }, "title":"input" }
  6. Escolha Criar modelo.

Agora você vai criar um modelo de saída. Esse modelo descreve a estrutura de dados da saída calculada do backend. Ele pode ser usado para mapear dados de resposta de integração para um modelo diferente. Este tutorial depende do comportamento de passagem direta e não usa este modelo.

Como criar um modelo de saída
  1. Escolha Criar modelo.

  2. Em Nome, digite output.

  3. Em Tipo de conteúdo, insira application/json.

    Se nenhum tipo de conteúdo correspondente for encontrado, a validação da solicitação não será executada. Para usar o mesmo modelo, independentemente do tipo de conteúdo, insira $default.

  4. Em Esquema do modelo, insira o seguinte modelo:

    { "type":"object", "properties":{ "c":{"type":"number"} }, "title":"output" }
  5. Escolha Criar modelo.

Agora você vai criar um modelo de resultado. Esse modelo descreve a estrutura de dados dos dados de resposta retornados. Ele faz referência aos esquemas de entrada e de saída definidos na API.

Como criar um modelo de resultado
  1. Escolha Criar modelo.

  2. Em Nome, digite result.

  3. Em Tipo de conteúdo, insira application/json.

    Se nenhum tipo de conteúdo correspondente for encontrado, a validação da solicitação não será executada. Para usar o mesmo modelo, independentemente do tipo de conteúdo, insira $default.

  4. Em Esquema do modelo, insira o modelo a seguir com o restapi-id. O restapi-id está listado entre parênteses na parte superior do console no seguinte fluxo: API Gateway > APIs > LambdaCalc (abc123).

    { "type":"object", "properties":{ "input":{ "$ref":"https://apigateway.amazonaws.com/restapis/restapi-id/models/input" }, "output":{ "$ref":"https://apigateway.amazonaws.com/restapis/restapi-id/models/output" } }, "title":"result" }
  5. Escolha Criar modelo.

Agora, você vai configurar a solicitação do método POST para habilitar a validação de solicitações no corpo da solicitação recebida.

Para habilitar a validação da solicitação no método POST
  1. No painel de navegação principal, selecione Recursos e, depois, selecione o método POST na árvore de recursos.

  2. Na guia Solicitação de método, em Configurações de solicitação de método, escolha Editar.

  3. Em Validador de solicitação, selecione Validar corpo.

  4. Selecione Corpo da solicitação e, depois, Adicionar modelo.

  5. Em Tipo de conteúdo, insira application/json.

    Se nenhum tipo de conteúdo correspondente for encontrado, a validação da solicitação não será executada. Para usar o mesmo modelo, independentemente do tipo de conteúdo, insira $default.

  6. Em Modelo, selecione entrada.

  7. Escolha Salvar.

Agora, é possível testar o método POST para verificar se ele foi configurado corretamente para invocar a função do Lambda:

Como testar o método POST
  1. Selecione a guia Testar. Talvez seja necessário selecionar o botão de seta para a direita para mostrar a guia.

  2. Em Corpo da solicitação, insira a carga útil do JSON a seguir.

    { "a": 1, "b": 2, "op": "+" }
  3. Escolha Testar.

    A seguinte saída deverá ser mostrada:

    { "a": 1, "b": 2, "op": "+", "c": 3 }

Integração 3: Criar um método GET com parâmetros de caminho para chamar a função do Lambda

Agora, você criará um método GET em um recurso especificado por uma sequência de parâmetros de caminho para chamar a função do Lambda de backend. Os valores de parâmetros de caminho especificam os dados de entrada para a função do Lambda. Você usará um modelo de mapeamento para mapear os valores de parâmetro de caminho de entrada para a carga necessária de solicitação de integração.

A aparência da estrutura de recursos de API resultante será semelhante a esta:


                Criar uma API no API Gateway como um proxy do Lambda
Como criar um recurso/{operand1}/{operand2}/{operator}
  1. Selecione Criar recurso.

  2. Em Caminho do recurso, selecione /calc.

  3. Em Resource Name (Nome do recurso), insira {operand1}.

  4. Mantenha CORS (Compartilhamento de recursos de origem cruzada) desativado.

  5. Selecione Criar recurso.

  6. Em Caminho do recurso, selecione /calc/{operand1}/.

  7. Em Resource Name (Nome do recurso), insira {operand2}.

  8. Mantenha CORS (Compartilhamento de recursos de origem cruzada) desativado.

  9. Selecione Criar recurso.

  10. Em Caminho do recurso, selecione /calc/{operand1}/{operand2}/.

  11. Em Resource Name (Nome do recurso), insira {operator}.

  12. Mantenha CORS (Compartilhamento de recursos de origem cruzada) desativado.

  13. Selecione Criar recurso.

Dessa vez, você usará a integração do Lambda incorporada no console do API Gateway para configurar a integração do método.

Como configurar uma integração de método
  1. Selecione o recurso /{operand1}/{operand2}/{operator} e, depois, escolha Criar método.

  2. Em Tipo de método, selecione GET.

  3. Em Tipo de integração, selecione Lambda.

  4. Mantenha a opção Integração do proxy do Lambda desativada.

  5. Para a função Lambda, selecione Região da AWS onde você criou sua função Lambda e insira. Calc

  6. Mantenha o Tempo limite padrão ativado.

  7. Escolha Criar método.

Agora, você vai criar um modelo de mapeamento para associar os três parâmetros de caminho de URL, declarados quando o recurso /calc/{operand1}/{operand2}/{operator} foi criado, a valores de propriedade designados no objeto JSON. Como os caminhos de URL devem ser codificados em URL, o operador de divisão deve ser especificado como %2F em vez de /. Esse modelo converte o %2F em '/' antes de transferi-lo para a função do Lambda.

Como criar um modelo de mapeamento
  1. Na guia Solicitação de integração, em Configurações de solicitação de integração, selecione Editar.

  2. Em Passagem do corpo da solicitação, selecione Quando não há modelos definidos (recomendado).

  3. Selecione Modelos de mapeamento.

  4. Em Tipo de conteúdo, insira application/json.

  5. Em Corpo do modelo, insira o seguinte código:

    { "a": "$input.params('operand1')", "b": "$input.params('operand2')", "op": #if($input.params('operator')=='%2F')"/"#{else}"$input.params('operator')"#end }
  6. Escolha Salvar.

Agora, é possível testar o método GET para verificar se ele foi configurado corretamente para invocar a função do Lambda e passar a saída original pela resposta de integração sem mapeamento.

Como testar o método GET
  1. Selecione a guia Testar. Talvez seja necessário selecionar o botão de seta para a direita para mostrar a guia.

  2. Para o Caminho, faça o seguinte:

    1. Em operand1, insira 1.

    2. Em operand2, insira 1.

    3. Em operador, insira +.

  3. Escolha Test (Testar).

  4. O resultado deve ser semelhante ao seguinte:

    
            Mapear os parâmetros de caminho de URL de solicitação de método para uma carga de solicitação de integração para chamar a função do Lambda

Depois, você modelará a estrutura de dados da carga útil de resposta de método após o esquema result.

Por padrão, o corpo de resposta de método recebe um modelo vazio. Isso fará com que o corpo de resposta de integração seja repassado sem mapeamento. No entanto, quando você gerar um SDK para uma das linguagens de tipo forte, como Java ou Objective-C, os usuários do seu SDK receberão um objeto vazio como resultado. Para garantir que tanto o cliente REST quanto os clientes do SDK recebam o resultado desejado, você deve modelar os dados de resposta usando uma esquema predefinido. Aqui, você definirá um modelo para o corpo de resposta de método e para construir um modelo de mapeamento a fim de traduzir o corpo da resposta de integração no corpo da resposta de método.

Como criar uma resposta de método
  1. Na guia Resposta de método, em Resposta 200, selecione Editar.

  2. Em Corpo da resposta, selecione Adicionar modelo.

  3. Em Tipo de conteúdo, insira application/json.

  4. Em Modelo, selecione o resultado.

  5. Escolha Salvar.

Definir o modelo result para o corpo da resposta de método garante que os dados da resposta serão convertidos no objeto de um determinado SDK. Para garantir que os dados de resposta de integração sejam mapeados de acordo, você precisará de um modelo de mapeamento.

Como criar um modelo de mapeamento
  1. Na guia Resposta de integração, em Padrão - Resposta, selecione Editar.

  2. Selecione Modelos de mapeamento.

  3. Em Tipo de conteúdo, insira application/json.

  4. Em Gerar modelo, selecione resultado.

  5. Modifique o modelo de mapeamento gerado para que corresponda ao seguinte:

    #set($inputRoot = $input.path('$')) { "input" : { "a" : $inputRoot.a, "b" : $inputRoot.b, "op" : "$inputRoot.op" }, "output" : { "c" : $inputRoot.c } }
  6. Escolha Salvar.

Como testar o modelo de mapeamento
  1. Selecione a guia Testar. Talvez seja necessário selecionar o botão de seta para a direita para mostrar a guia.

  2. Para o Caminho, faça o seguinte:

    1. Em operand1, insira 1.

    2. Em operand2, insira 2.

    3. Em operador, insira +.

  3. Escolha Testar.

  4. O resultado terá esta aparência:

    { "input": { "a": 1, "b": 2, "op": "+" }, "output": { "c": 3 } }

Nesse momento, somente é possível chamar a API usando o atributo Testar no console do API Gateway. Para disponibilizá-la para os clientes, será necessário implantar a API. Certifique-se de reimplantar sua API sempre que você adicionar, modificar ou excluir um recurso ou método, atualizar um mapeamento de dados ou atualizar as configurações de estágio. Caso contrário, novos atributos ou atualizações não estarão disponíveis para clientes da API.

Para implantar a API
  1. Escolha Deploy API (Implantar API).

  2. Em Estágio, selecione Novo estágio.

  3. Em Stage name (Nome do estágio), insira Prod.

  4. (Opcional) Em Description (Descrição), insira uma descrição.

  5. Escolha Implantar.

  6. (Opcional) Em Detalhes do estágio, para Invocar URL, é possível selecionar o ícone de cópia para copiar o URL de invocação da API. Você pode usá-lo com ferramentas, como Postman e cURL para testar sua API.

nota

Reimplante a API sempre que você adicionar, modificar ou excluir um recurso ou um método, atualizar um mapeamento de dados ou atualizar as configurações de estágio. Caso contrário, novos recursos ou atualizações não estarão disponíveis para clientes de sua API.