

# Invocar URLs de função do Lambda
<a name="urls-invocation"></a>

Um URL de função é um endpoint HTTP(S) dedicado para a função do Lambda. Você pode criar e configurar um URL de função no console do Lambda ou na API do Lambda.

**dica**  
O Lambda oferece duas maneiras de invocar sua função por meio de um endpoint HTTP: URLs de função e Amazon API Gateway. Se não tiver certeza de qual é o melhor método para seu caso de uso, consulte [Seleção de um método para invocar a função do Lambda usando uma solicitação HTTP](furls-http-invoke-decision.md).

Ao criar um URL de função, o Lambda gera automaticamente um endpoint de URL exclusivo para você. Após a criação de um URL de função, o endpoint de URL nunca muda. Os endpoints de URLs de função têm o seguinte formato:

```
https://<url-id>.lambda-url.<region>.on.aws
```

**nota**  
Os URLs da função não são compatíveis com as seguintes Regiões da AWS: Ásia-Pacífico (Hyderabad) (`ap-south-2`), Ásia-Pacífico (Melbourne) (`ap-southeast-4`), Ásia-Pacífico (Malásia) (`ap-southeast-5`), Ásia-Pacífico (Nova Zelândia) (`ap-southeast-6`), Ásia-Pacífico (Tailândia) (`ap-southeast-7`), Ásia-Pacífico (Taipei) (`ap-east-2`), Oeste do Canadá (Calgary) (`ca-west-1`), Europa (Espanha) (`eu-south-2`), Europa (Zurique) (`eu-central-2`), Israel (Tel Aviv) (`il-central-1`), e Oriente Médio (EAU) (`me-central-1`).

Os URLs de função são habilitados para pilha dupla, sendo compatíveis com IPv4 e IPv6. Após configurar o URL de função, você pode invocar a função por meio de seu endpoint HTTP(S) via um navegador da Web, curl, Postman ou qualquer cliente HTTP. Para invocar um URL da função, você deve ter permissões `lambda:InvokeFunctionUrl` e `lambda:InvokeFunction`. Para obter mais informações, consulte [Controle de acesso](urls-auth.md).

**Topics**
+ [Noções básicas sobre invocação de URL de função](#urls-invocation-basics)
+ [Cargas úteis de solicitações e respostas](#urls-payloads)

## Noções básicas sobre invocação de URL de função
<a name="urls-invocation-basics"></a>

Se o URL de função usar o tipo de autenticação, `AWS_IAM`você deve assinar cada solicitação HTTP usando a \$1[AWS Signature Version 4 (SigV4)](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html)\$1. Ferramentas como [Postman](https://quickstarts.postman.com/guide/aws/index.html?index=..%2F..index#2) oferecem maneiras integradas de assinar solicitações com o Sigv4.

Se não usar uma ferramenta para assinar as solicitações HTTP ao URL de função, você deverá assinar manualmente cada solicitação usando o SigV4. Quando o URL de função recebe uma solicitação, o Lambda também analisa a assinatura do Sigv4. O Lambda só processa a solicitação se as assinaturas corresponderem. Para obter instruções sobre como assinar manualmente as solicitações com o SigV4, consulte [Assinar solicitações da AWS com o Signature versão 4](https://docs.aws.amazon.com/general/latest/gr/sigv4_signing.html), no *Guia Referência geral da Amazon Web Services*.

Se o URL de função usar o tipo de autenticação `NONE`, você não precisará assinar as solicitações usando o Sigv4. Você pode invocar a função usando um navegador da Web, curl, Postman ou qualquer cliente HTTP.

Para testar simples solicitações `GET` à função, use um navegador da Web. Por exemplo, se o URL de função for `https://abcdefg.lambda-url.us-east-1.on.aws` e aceitar um parâmetro de string `message`, o URL de solicitação pode ser semelhante a este:

```
https://abcdefg.lambda-url.us-east-1.on.aws/?message=HelloWorld
```

Para testar outras solicitações HTTP, como uma solicitação `POST`, você pode usar uma ferramenta como curl. Por exemplo, se quiser incluir alguns dados JSON em uma solicitação `POST` ao URL de função, você poderá usar o seguinte comando curl:

```
curl -v 'https://abcdefg.lambda-url.us-east-1.on.aws/?message=HelloWorld' \
-H 'content-type: application/json' \
-d '{ "example": "test" }'
```

## Cargas úteis de solicitações e respostas
<a name="urls-payloads"></a>

Quando um cliente chama o URL de função, o Lambda mapeia a solicitação para um objeto de evento antes de passá-la para a função. A resposta da função é então mapeada para uma resposta HTTP que o Lambda envia de volta ao cliente por meio do URL de função.

Os formatos de evento de solicitação e resposta seguem o mesmo esquema do [formato de carga útil do Amazon API Gateway versão 2.0](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html#http-api-develop-integrations-lambda.proxy-format).

### Formato de carga útil de solicitação
<a name="urls-request-payload"></a>

Uma carga útil de solicitação tem a seguinte estrutura:

```
{
  "version": "2.0",
  "routeKey": "$default",
  "rawPath": "/my/path",
  "rawQueryString": "parameter1=value1&parameter1=value2&parameter2=value",
  "cookies": [
    "cookie1",
    "cookie2"
  ],
  "headers": {
    "header1": "value1",
    "header2": "value1,value2"
  },
  "queryStringParameters": {
    "parameter1": "value1,value2",
    "parameter2": "value"
  },
  "requestContext": {
    "accountId": "123456789012",
    "apiId": "<urlid>",
    "authentication": null,
    "authorizer": {
        "iam": {
                "accessKey": "AKIA...",
                "accountId": "111122223333",
                "callerId": "AIDA...",
                "cognitoIdentity": null,
                "principalOrgId": null,
                "userArn": "arn:aws:iam::111122223333:user/example-user",
                "userId": "AIDA..."
        }
    },
    "domainName": "<url-id>.lambda-url.us-west-2.on.aws",
    "domainPrefix": "<url-id>",
    "http": {
      "method": "POST",
      "path": "/my/path",
      "protocol": "HTTP/1.1",
      "sourceIp": "123.123.123.123",
      "userAgent": "agent"
    },
    "requestId": "id",
    "routeKey": "$default",
    "stage": "$default",
    "time": "12/Mar/2020:19:03:58 +0000",
    "timeEpoch": 1583348638390
  },
  "body": "Hello from client!",
  "pathParameters": null,
  "isBase64Encoded": false,
  "stageVariables": null
}
```


| Parameter | Descrição | Exemplo | 
| --- | --- | --- | 
|  `version`  |  A versão do formato de carga útil para esse evento. Atualmente, os URLs de função do Lambda são compatíveis com o [formato de carga útil versão 2.0](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html#http-api-develop-integrations-lambda.proxy-format).  |  `2.0`  | 
|  `routeKey`  |  URLs de função não usam esse parâmetro. O Lambda define isso como `$default` para marcar um espaço reservado.  |  `$default`  | 
|  `rawPath`  |  O caminho da solicitação. Por exemplo, se o URL de solicitação for `https://{url-id}.lambda-url.{region}.on.aws/example/test/demo`, o valor do caminho bruto será `/example/test/demo`.  |  `/example/test/demo`  | 
|  `rawQueryString`  |  A string bruta que contém os parâmetros de string de consulta da solicitação. Os caracteres compatíveis incluem `a-z`, `A-Z`, `0-9`, `.`, `_`, `-`, `%`, `&`, `=` e `+`.  |  `"?parameter1=value1&parameter2=value2"`  | 
|  `cookies`  |  Uma matriz contendo todos os cookies enviados como parte da solicitação.  |  `["Cookie_1=Value_1", "Cookie_2=Value_2"]`  | 
|  `headers`  |  A lista de cabeçalhos de solicitação, apresentada como pares chave-valor.  |  `{"header1": "value1", "header2": "value2"}`  | 
|  `queryStringParameters`  |  Os parâmetros de consulta para a solicitação. Por exemplo, se o URL de solicitação for `https://{url-id}.lambda-url.{region}.on.aws/example?name=Jane`, o valor `queryStringParameters` será um objeto JSON com uma chave `name` e um valor `Jane`.  |  `{"name": "Jane"}`  | 
|  `requestContext`  |  Um objeto que contém informações adicionais sobre a solicitação, como o `requestId`, a hora da solicitação e a identidade do chamador se autorizado pelo AWS Identity and Access Management (IAM).  |   | 
|  `requestContext.accountId`  |  O ID da Conta da AWS do proprietário da função.  |  `"123456789012"`  | 
|  `requestContext.apiId`  |  O ID do URL de função.  |  `"33anwqw8fj"`  | 
|  `requestContext.authentication`  |  URLs de função não usam esse parâmetro. O Lambda define isso como `null`.  |  `null`  | 
|  `requestContext.authorizer`  |  Um objeto que contém informações sobre a identidade do chamador, se o URL de função usar o tipo de autenticação `AWS_IAM`. Do contrário, o Lambda define isso como `null`.  |   | 
|  `requestContext.authorizer.iam.accessKey`  |  A chave de acesso da identidade do chamador.  |  `"AKIAIOSFODNN7EXAMPLE"`  | 
|  `requestContext.authorizer.iam.accountId`  |  O ID da Conta da AWS da identidade do chamador.  |  `"111122223333"`  | 
|  `requestContext.authorizer.iam.callerId`  |  O ID (ID do usuário) do chamador.  |  `"AIDACKCEVSQ6C2EXAMPLE"`  | 
|  `requestContext.authorizer.iam.cognitoIdentity`  |  URLs de função não usam esse parâmetro. O Lambda define isso como `null` ou exclui isso do JSON.  |  `null`  | 
|  `requestContext.authorizer.iam.principalOrgId`  |  O ID da organização da entidade principal associado à identidade do chamador.  |  `"AIDACKCEVSQORGEXAMPLE"`  | 
|  `requestContext.authorizer.iam.userArn`  |  O nome do recurso da Amazon (ARN) do usuário da identidade do chamador.  |  `"arn:aws:iam::111122223333:user/example-user"`  | 
|  `requestContext.authorizer.iam.userId`  |  O ID de usuário da identidade do chamador.  |  `"AIDACOSFODNN7EXAMPLE2"`  | 
|  `requestContext.domainName`  |  O nome do domínio do URL de função.  |  `"<url-id>.lambda-url.us-west-2.on.aws"`  | 
|  `requestContext.domainPrefix`  |  O prefixo do domínio do URL de função.  |  `"<url-id>"`  | 
|  `requestContext.http`  |  Um objeto que contém detalhes sobre a solicitação HTTP.  |   | 
|  `requestContext.http.method`  |  O método HTTP usado na solicitação. Os valores válidos incluem `GET`, `POST`, `PUT`, `HEAD`, `OPTIONS`, `PATCH` e `DELETE`.  |  `GET`  | 
|  `requestContext.http.path`  |  O caminho da solicitação. Por exemplo, se o URL de solicitação for `https://{url-id}.lambda-url.{region}.on.aws/example/test/demo`, o valor do caminho será `/example/test/demo`.  |  `/example/test/demo`  | 
|  `requestContext.http.protocol`  |  O protocolo da solicitação.  |  `HTTP/1.1`  | 
|  `requestContext.http.sourceIp`  |  O endereço IP de origem da conexão TCP imediata que está fazendo a solicitação.  |  `123.123.123.123`  | 
|  `requestContext.http.userAgent`  |  O valor do cabeçalho da solicitação User-Agent.  |  `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Gecko/20100101 Firefox/42.0`  | 
|  `requestContext.requestId`  |  O ID da solicitação da invocação. Você pode usar esse ID para logs de invocações relacionadas à função.  |  `e1506fd5-9e7b-434f-bd42-4f8fa224b599`  | 
|  `requestContext.routeKey`  |  URLs de função não usam esse parâmetro. O Lambda define isso como `$default` para marcar um espaço reservado.  |  `$default`  | 
|  `requestContext.stage`  |  URLs de função não usam esse parâmetro. O Lambda define isso como `$default` para marcar um espaço reservado.  |  `$default`  | 
|  `requestContext.time`  |  O timestamp da solicitação.  |  `"07/Sep/2021:22:50:22 +0000"`  | 
|  `requestContext.timeEpoch`  |  O timestamp da solicitação, no horário da era UNIX.  |  `"1631055022677"`  | 
|  `body`  |  O corpo da solicitação. Se o tipo de conteúdo da solicitação for binário, o corpo será codificado na base 64.  |  `{"key1": "value1", "key2": "value2"}`  | 
|  `pathParameters`  |  URLs de função não usam esse parâmetro. O Lambda define isso como `null` ou exclui isso do JSON.  |  `null`  | 
|  `isBase64Encoded`  |  `TRUE` se o corpo for uma carga útil binária e for codificado na base 64. `FALSE` nos demais casos.  |  `FALSE`  | 
|  `stageVariables`  |  URLs de função não usam esse parâmetro. O Lambda define isso como `null` ou exclui isso do JSON.  |  `null`  | 

### Formato de carga útil de resposta
<a name="urls-response-payload"></a>

Quando a função retorna uma resposta, o Lambda analisa a resposta e converte-a em uma resposta HTTP. As cargas úteis de resposta de função têm o seguinte formato:

```
{
   "statusCode": 201,
    "headers": {
        "Content-Type": "application/json",
        "My-Custom-Header": "Custom Value"
    },
    "body": "{ \"message\": \"Hello, world!\" }",
    "cookies": [
        "Cookie_1=Value1; Expires=21 Oct 2021 07:48 GMT",
        "Cookie_2=Value2; Max-Age=78000"
    ],
    "isBase64Encoded": false
}
```

O Lambda infere o formato de resposta para você. Se a função do Lambda retornar JSON válido e não retornar um `statusCode`, o Lambda pressupõe o seguinte:
+ `statusCode` is `200`.
**nota**  
Os `statusCode` válidos vão de 100 a 599.
+ `content-type` is `application/json`.
+ `body` é a resposta da função.
+ `isBase64Encoded` is `false`.

Os exemplos a seguir mostram como a saída da função do Lambda é mapeada para a carga útil da resposta e como a carga útil da resposta é mapeada para a resposta HTTP final. Quando o cliente invoca o URL de função, ele vê a resposta HTTP.

**Exemplo de saída para uma resposta de string**


| Saída da função do Lambda | Saída de resposta interpretada | Resposta HTTP (o que o cliente vê) | 
| --- | --- | --- | 
|  <pre>"Hello, world!"</pre>  |  <pre>{<br />  "statusCode": 200,<br />  "body": "Hello, world!",<br />  "headers": {<br />    "content-type": "application/json"<br />  },<br />  "isBase64Encoded": false<br />}</pre>  |  <pre>HTTP/2 200<br />date: Wed, 08 Sep 2021 18:02:24 GMT<br />content-type: application/json<br />content-length: 15<br /><br />"Hello, world!"</pre>  | 

**Exemplo de saída para uma resposta em JSON**


| Saída da função do Lambda | Saída de resposta interpretada | Resposta HTTP (o que o cliente vê) | 
| --- | --- | --- | 
|  <pre>{<br />  "message": "Hello, world!"<br />}</pre>  |  <pre>{<br />  "statusCode": 200,<br />  "body": {<br />    "message": "Hello, world!"<br />  },<br />  "headers": {<br />    "content-type": "application/json"<br />  },<br />  "isBase64Encoded": false<br />}</pre>  |  <pre>HTTP/2 200<br />date: Wed, 08 Sep 2021 18:02:24 GMT<br />content-type: application/json<br />content-length: 34<br /><br />{<br />  "message": "Hello, world!"<br />}</pre>  | 

**Exemplo de saída para uma resposta personalizada**


| Saída da função do Lambda | Saída de resposta interpretada | Resposta HTTP (o que o cliente vê) | 
| --- | --- | --- | 
|  <pre>{<br />   "statusCode": 201,<br />    "headers": {<br />        "Content-Type": "application/json",<br />        "My-Custom-Header": "Custom Value"<br />    },<br />    "body": JSON.stringify({<br />        "message": "Hello, world!"<br />    }),<br />    "isBase64Encoded": false<br />}</pre>  |  <pre>{<br />   "statusCode": 201,<br />    "headers": {<br />        "Content-Type": "application/json",<br />        "My-Custom-Header": "Custom Value"<br />    },<br />    "body": JSON.stringify({<br />        "message": "Hello, world!"<br />    }),<br />    "isBase64Encoded": false<br />}</pre>  |  <pre>HTTP/2 201<br />date: Wed, 08 Sep 2021 18:02:24 GMT<br />content-type: application/json<br />content-length: 27<br />my-custom-header: Custom Value<br /><br />{<br />  "message": "Hello, world!"<br />}</pre>  | 

### Cookies
<a name="urls-cookies"></a>

Para retornar cookies da função, não adicione manualmente cabeçalhos `set-cookie`. Em vez disso, inclua os cookies no objeto de carga útil da resposta. O Lambda interpreta isso automaticamente e adiciona-os como cabeçalhos `set-cookie` na resposta HTTP, como no exemplo a seguir.


| Saída da função do Lambda | Resposta HTTP (o que o cliente vê) | 
| --- | --- | 
|  <pre>{<br />   "statusCode": 201,<br />    "headers": {<br />        "Content-Type": "application/json",<br />        "My-Custom-Header": "Custom Value"<br />    },<br />    "body": JSON.stringify({<br />        "message": "Hello, world!"<br />    }),<br />    "cookies": [<br />        "Cookie_1=Value1; Expires=21 Oct 2021 07:48 GMT",<br />        "Cookie_2=Value2; Max-Age=78000"<br />    ],<br />    "isBase64Encoded": false<br />}</pre>  |  <pre>HTTP/2 201<br />date: Wed, 08 Sep 2021 18:02:24 GMT<br />content-type: application/json<br />content-length: 27<br />my-custom-header: Custom Value<br />set-cookie: Cookie_1=Value2; Expires=21 Oct 2021 07:48 GMT<br />set-cookie: Cookie_2=Value2; Max-Age=78000<br /><br />{<br />  "message": "Hello, world!"<br />}</pre>  | 