# Usar o objeto de contexto do Lambda para recuperar informações das funções em Go
No Lambda, o objeto de contexto disponibiliza métodos e propriedades que contêm informações sobre a invocação, a função e o ambiente de execução. Quando o Lambda executa a função, ele transmite um objeto de contexto para o [handler](golang-handler.md). Para usar o objeto de contexto no seu manipulador, você pode, opcionalmente, declará-lo como um parâmetro de entrada no manipulador. O objeto de contexto é necessário caso você deseje realizar o seguinte no seu manipulador:
+ É necessário ter acesso às [variáveis globais, aos métodos ou às propriedades](#golang-context-library) fornecidos pelo objeto de contexto. Esses métodos e essas propriedades são úteis para tarefas como determinar a entidade que invocou sua função ou medir o tempo de invocação da função, como ilustrado em [Acessar informações do contexto de invocação](#golang-context-access).
+ É necessário usar o AWS SDK para Go para realizar chamadas a outros serviços. O objeto de contexto é um parâmetro de entrada importante para a maioria dessas chamadas. Para ter mais informações, consulte [Uso do contexto nas inicializações e nas chamadas do cliente do AWS SDK](#golang-context-sdk).
**Topics**
+ [Variáveis, métodos e propriedades compatíveis no objeto de contexto](#golang-context-library)
+ [Acessar informações do contexto de invocação](#golang-context-access)
+ [Uso do contexto nas inicializações e nas chamadas do cliente do AWS SDK](#golang-context-sdk)
## Variáveis, métodos e propriedades compatíveis no objeto de contexto
A biblioteca de contexto do Lambda fornece as seguintes variáveis globais, métodos e propriedades.
**Variáveis globais**
+ `FunctionName`: o nome da função do Lambda.
+ `FunctionVersion`: a [versão](configuration-versions.md) da função.
+ `MemoryLimitInMB`: a quantidade de memória alocada para a função.
+ `LogGroupName`: o grupo de logs da função.
+ `LogStreamName`: a transmissão de log para a instância da função.
**Métodos de contexto**
+ `Deadline`— Retorna a data em que a execução expira o tempo em milissegundos do Unix.
**Propriedades de contexto**
+ `InvokedFunctionArn`: o nome do recurso da Amazon (ARN) usado para invocar a função. Indica se o invocador especificou um alias ou número de versão.
+ `AwsRequestID`: o identificador da solicitação de invocação.
+ `Identity`: (aplicativos móveis) informações sobre a identidade do Amazon Cognito que autorizou a solicitação.
+ `ClientContext`: (aplicativos móveis) contexto do cliente fornecido ao Lambda pela aplicação cliente.
## Acessar informações do contexto de invocação
As funções do Lambda têm acesso aos metadados sobre seu ambiente e a solicitação da invocação. Isso pode ser acessado no [Contexto do pacote](https://golang.org/pkg/context/). Se o manipulador incluir `context.Context` como um parâmetro, o Lambda inserirá informações sobre sua função na propriedade `Value` do contexto. Observe que você precisa importar a biblioteca `lambdacontext` para acessar o conteúdo do objeto `context.Context`.
```
package main
import (
"context"
"log"
"github.com/aws/aws-lambda-go/lambda"
"github.com/aws/aws-lambda-go/lambdacontext"
)
func CognitoHandler(ctx context.Context) {
lc, _ := lambdacontext.FromContext(ctx)
log.Print(lc.Identity.CognitoIdentityPoolID)
}
func main() {
lambda.Start(CognitoHandler)
}
```
No exemplo acima, `lc` é a variável usada para consumir as informações que o objeto de contexto capturou, e `log.Print(lc.Identity.CognitoIdentityPoolID)` imprime essas informações, neste caso, o CognitoIdentityPoolID.
O exemplo a seguir mostra como usar o objeto de contexto para monitorar o tempo necessário para concluir a função do Lambda. Isso permite que você analise as expectativas de performance e ajuste seu código de função de maneira correspondente, se necessário.
```
package main
import (
"context"
"log"
"time"
"github.com/aws/aws-lambda-go/lambda"
)
func LongRunningHandler(ctx context.Context) (string, error) {
deadline, _ := ctx.Deadline()
deadline = deadline.Add(-100 * time.Millisecond)
timeoutChannel := time.After(time.Until(deadline))
for {
select {
case <- timeoutChannel:
return "Finished before timing out.", nil
default:
log.Print("hello!")
time.Sleep(50 * time.Millisecond)
}
}
}
func main() {
lambda.Start(LongRunningHandler)
}
```
## Uso do contexto nas inicializações e nas chamadas do cliente do AWS SDK
Caso o seu manipulador precise usar o AWS SDK para Go para fazer chamadas a outros serviços, inclua o objeto de contexto como um parâmetro de entrada no manipulador. Na AWS, é considerado uma prática recomendada fornecer o objeto de contexto na maioria das chamadas do AWS SDK. Por exemplo, a chamada `PutObject` do Amazon S3 aceita o objeto de contexto (`ctx`) como seu primeiro argumento:
```
// Upload an object to S3
_, err = s3Client.PutObject(ctx, &s3.PutObjectInput{
...
})
```
Para realizar a inicialização adequada dos seus clientes do SDK, também é possível usar o objeto de contexto para carregar a configuração correta antes de fornecer esse objeto de configuração ao cliente:
```
// Load AWS SDK configuration using the default credential provider chain
cfg, err := config.LoadDefaultConfig(ctx)
...
s3Client = s3.NewFromConfig(cfg)
```
Caso você deseje inicializar seus clientes do SDK de forma externa ao manipulador principal (isto é, durante a fase de inicialização), é possível fornecer um objeto de contexto como espaço reservado:
```
func init() {
// Initialize the S3 client outside of the handler, during the init phase
cfg, err := config.LoadDefaultConfig(context.TODO())
...
s3Client = s3.NewFromConfig(cfg)
}
```
Se você optar por inicializar seus clientes dessa forma, é importante garantir que o objeto de contexto correto seja fornecido nas chamadas do SDK realizadas pelo seu manipulador principal.