

# 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 {[AWS Signature Version 4 (SigV4)](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html)}. 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>  | 