# Criar funções do Lambda com Go
<a name="lambda-golang"></a>

O Go é implementado de forma diferente de outros runtimes gerenciados. Como o Go é compilado nativamente com um binário executável, ele não requer um runtime de linguagem dedicado. Use um [runtime somente de sistema operacional](runtimes-provided.md) (a família de runtime `provided`) para implantar funções do Go no Lambda.

**Topics**
+ [

## Suporte do runtime do Go
](#golang-al1)
+ [

## Ferramentas e bibliotecas
](#golang-libraries)
+ [

# Definição dos manipuladores de função do Lambda em Go
](golang-handler.md)
+ [

# Usar o objeto de contexto do Lambda para recuperar informações das funções em Go
](golang-context.md)
+ [

# Implantar funções do Lambda em Go com arquivos .zip
](golang-package.md)
+ [

# Implantar funções do Lambda em Go com imagens de contêiner
](go-image.md)
+ [

# Como trabalhar com camadas para funções do Lambda em Go
](golang-layers.md)
+ [

# Registrar em log e monitorar funções do Lambda em Go
](golang-logging.md)
+ [

# Instrumentação do código Go no AWS Lambda
](golang-tracing.md)

## Suporte do runtime do Go
<a name="golang-al1"></a>

O runtime gerenciado do Go 1.x para Lambda foi [descontinuado](lambda-runtimes.md#runtime-support-policy). Se tiver funções que usem o runtime do Go 1.x, você deverá migrar suas funções para `provided.al2023` ou `provided.al2`. Os runtimes `provided.al2023` e `provided.al2` oferecem várias vantagens em comparação ao `go1.x`, incluindo compatibilidade com a arquitetura arm64 (processadores AWS Graviton2), binários menores e tempos de invocação um pouco mais rápidos.

Nenhuma alteração de código é necessária para essa migração. As únicas alterações necessárias estão relacionadas à forma como você cria seu pacote de implantação e ao runtime que você usa para criar sua função. Para obter mais informações, consulte [Migrating AWS Lambda functions from the Go1.x runtime to the custom runtime on Amazon Linux 2](https://aws.amazon.com/blogs/compute/migrating-aws-lambda-functions-from-the-go1-x-runtime-to-the-custom-runtime-on-amazon-linux-2/) no *AWS Compute Blog*.


| Nome | Identificador | Sistema operacional | Data da substituição | Bloquear a criação de funções | Bloquear a atualização de funções | 
| --- | --- | --- | --- | --- | --- | 
|  Runtime somente para sistema operacional  |  `provided.al2023`  |  Amazon Linux 2023  |   30 de junho de 2029   |   31 de julho de 2029   |   31 de agosto de 2029   | 
|  Runtime somente para sistema operacional  |  `provided.al2`  |  Amazon Linux 2  |   31 de julho de 2026   |   31 de agosto de 2026   |   30 de setembro de 2026   | 

## Ferramentas e bibliotecas
<a name="golang-libraries"></a>

O Lambda fornece as seguintes ferramentas e bibliotecas para o runtime do Go:
+ [AWS SDK para Go v2](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2): o SDK oficial da AWS para a linguagem de programação Go.
+ [github.com/aws/aws-lambda-go/lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda): a implementação do modelo de programação do Lambda para Go. Esse pacote é usado pelo AWS Lambda para invocar o [handler](golang-handler.md).
+ [github.com/aws/aws-lambda-go/lambdacontext](https://github.com/aws/aws-lambda-go/tree/master/lambdacontext): auxiliares para acesso a informações do [objeto de contexto](golang-context.md).
+ [github.com/aws/aws-lambda-go/events](https://github.com/aws/aws-lambda-go/tree/master/events): esta biblioteca fornece definições de tipos para integrações comuns de origens de eventos.
+ [github.com/aws/aws-lambda-go/cmd/build-lambda-zip](https://github.com/aws/aws-lambda-go/tree/master/cmd/build-lambda-zip): Esta ferramenta pode ser usada para criar um archive com arquivo .zip no Windows.

Para obter mais informações, consulte [aws-lambda-go](https://github.com/aws/aws-lambda-go) no GitHub.

O Lambda fornece as seguintes aplicações de exemplo para o runtime do Go:

**Aplicativos do Lambda de exemplo do em Go**
+ [go-al2](https://github.com/aws-samples/sessions-with-aws-sam/tree/master/go-al2): uma função olá, mundo que retorna o endereço IP público. Esta aplicação usa o runtime `provided.al2` personalizado.
+ [blank-go](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-go): uma função do Go que mostra o uso das bibliotecas do Go do Lambda, o registro em log, as variáveis de ambiente e o AWS SDK. Esta aplicação usa o runtime `go1.x`.

# Definição dos manipuladores de função do Lambda em Go
<a name="golang-handler"></a>

O *manipulador* da função do Lambda é o método no código da função que processa eventos. Quando sua função é invocada, o Lambda executa o método do manipulador. A função é executada até que o manipulador retorne uma resposta, seja encerrado ou atinja o tempo limite.

Esta página descreve como trabalhar com manipuladores de função do Lambda em Go, incluindo a configuração de projeto, as convenções de nomenclatura e as práticas recomendadas. Além disso, esta página apresenta um exemplo de uma função do Lambda em Go que aceita informações sobre um pedido, produz um recibo em formato de texto e armazena esse arquivo em um bucket do Amazon Simple Storage Service (Amazon S3). Para obter mais informações sobre como implantar a função após gravá-la, consulte [Implantar funções do Lambda em Go com arquivos .zip](golang-package.md) ou [Implantar funções do Lambda em Go com imagens de contêiner](go-image.md).

**Topics**
+ [

## Configuração do projeto de manipulador em Go
](#golang-handler-setup)
+ [

## Exemplo de código de função do Lambda em Go
](#golang-example-code)
+ [

## Convenções de nomenclatura para manipuladores
](#golang-handler-naming)
+ [

## Definição e acesso ao objeto do evento de entrada
](#golang-example-input)
+ [

## Acesso e uso do objeto de contexto do Lambda
](#golang-example-context)
+ [

## Assinaturas de manipulador válidas para manipuladores em Go
](#golang-handler-signatures)
+ [

## Uso do AWS SDK para Go v2 em seu manipulador
](#golang-example-sdk-usage)
+ [

## Acesso a variáveis de ambiente
](#golang-example-envvars)
+ [

## Usar o estado global
](#golang-handler-state)
+ [

## Práticas recomendadas de código para as funções do Lambda em GO
](#go-best-practices)

## Configuração do projeto de manipulador em Go
<a name="golang-handler-setup"></a>

Uma função do Lambda escrita em [Go](https://golang.org/) é criada como um executável do Go. É possível inicializar um projeto de função do Lambda em Go da mesma forma que inicializa qualquer outro projeto em Go, usando o seguinte comando `go mod init`:

```
go mod init example-go
```

Neste caso, `example-go` é o nome do módulo. Você pode substituí-lo por qualquer nome que desejar. Este comando inicializa seu projeto e gera o arquivo `go.mod`, que lista as dependências do projeto.

Use o comando `go get` para adicionar quaisquer dependências externas ao seu projeto. Por exemplo, para todas as funções do Lambda em Go, é necessário incluir o pacote [github.com/aws/aws-lambda-go/lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda), que implementa o modelo de programação do Lambda para Go. Para incluir este pacote, use o seguinte comando `go get`:

```
go get github.com/aws/aws-lambda-go
```

O código da sua função deve estar em um arquivo em Go. No exemplo apresentado a seguir, chamamos esse arquivo de `main.go`. Neste arquivo, você implementa a lógica principal da função em um método manipulador, bem como uma função `main()` que chama esse manipulador.

## Exemplo de código de função do Lambda em Go
<a name="golang-example-code"></a>

O exemplo de código apresentado a seguir para uma função do Lambda em Go aceita informações sobre um pedido, produz um recibo em formato de texto e armazena esse arquivo em um bucket do Amazon S3.

**Example Função do Lambda em `main.go`**  

```
package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"os"
	"strings"

	"github.com/aws/aws-lambda-go/lambda"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/service/s3"
)

type Order struct {
	OrderID string  `json:"order_id"`
	Amount  float64 `json:"amount"`
	Item    string  `json:"item"`
}

var (
	s3Client *s3.Client
)

func init() {
	// Initialize the S3 client outside of the handler, during the init phase
	cfg, err := config.LoadDefaultConfig(context.TODO())
	if err != nil {
		log.Fatalf("unable to load SDK config, %v", err)
	}

	s3Client = s3.NewFromConfig(cfg)
}

func uploadReceiptToS3(ctx context.Context, bucketName, key, receiptContent string) error {
	_, err := s3Client.PutObject(ctx, &s3.PutObjectInput{
		Bucket: &bucketName,
		Key:    &key,
		Body:   strings.NewReader(receiptContent),
	})
	if err != nil {
		log.Printf("Failed to upload receipt to S3: %v", err)
		return err
	}
	return nil
}

func handleRequest(ctx context.Context, event json.RawMessage) error {
	// Parse the input event
	var order Order
	if err := json.Unmarshal(event, &order); err != nil {
		log.Printf("Failed to unmarshal event: %v", err)
		return err
	}

	// Access environment variables
	bucketName := os.Getenv("RECEIPT_BUCKET")
	if bucketName == "" {
		log.Printf("RECEIPT_BUCKET environment variable is not set")
		return fmt.Errorf("missing required environment variable RECEIPT_BUCKET")
	}

	// Create the receipt content and key destination
	receiptContent := fmt.Sprintf("OrderID: %s\nAmount: $%.2f\nItem: %s",
		order.OrderID, order.Amount, order.Item)
	key := "receipts/" + order.OrderID + ".txt"

	// Upload the receipt to S3 using the helper method
	if err := uploadReceiptToS3(ctx, bucketName, key, receiptContent); err != nil {
		return err
	}

	log.Printf("Successfully processed order %s and stored receipt in S3 bucket %s", order.OrderID, bucketName)
	return nil
}

func main() {
	lambda.Start(handleRequest)
}
```

Este arquivo `main.go` contém as seguintes seções de código:
+ `package main`: na linguagem Go, o pacote que contém a função `func main()` deve sempre ser nomeado como `main`.
+ Bloco `import`: utilize este bloco para incluir as bibliotecas necessárias para a função do Lambda.
+ Bloco `type Order struct {}`: define o formato do evento de entrada esperado nesta estrutura em Go.
+ Bloco `var ()`: use este bloco para definir quaisquer variáveis globais que você usará na função do Lambda.
+ `func init() {}`: inclua qualquer código que você deseja que o Lambda execute durante a [fase de inicialização](lambda-runtime-environment.md#runtimes-lifecycle-ib) neste método `init()`.
+ `func uploadReceiptToS3(...) {}`: este é um método auxiliar que é referenciado pelo método principal do manipulador `handleRequest`.
+ `func handleRequest(ctx context.Context, event json.RawMessage) error {}`: este é o **método principal do manipulador**, que contém a lógica principal da sua aplicação.
+ `func main() {}`: este é um ponto de entrada obrigatório para seu manipulador do Lambda. O argumento para o método `lambda.Start()` corresponde ao seu método principal do manipulador.

Para que esta função funcione corretamente, seu [perfil de execução](lambda-intro-execution-role.md) deve permitir a ação `s3:PutObject`. Além disso, certifique-se de definir a variável de ambiente `RECEIPT_BUCKET`. Após uma invocação com êxito, o bucket do Amazon S3 deve conter um arquivo de recibo.

## Convenções de nomenclatura para manipuladores
<a name="golang-handler-naming"></a>

Para funções do Lambda em Go, você pode usar qualquer nome para o manipulador. Neste exemplo, o nome do método do manipulador é `handleRequest`. Para referenciar o valor do manipulador em seu código, você pode usar a variável de ambiente `_HANDLER`.

Para funções em Go implantadas usando um [pacote de implantação .zip](golang-package.md), o arquivo executável que contém o código da sua função deve ser nomeado `bootstrap`. Além disso, o arquivo `bootstrap` deve estar na raiz do arquivo .zip. Para funções em Go implantadas usando uma [imagem de contêiner](go-image.md#go-image-provided), é possível usar qualquer nome para o arquivo executável.

## Definição e acesso ao objeto do evento de entrada
<a name="golang-example-input"></a>

O formato de entrada JSON é o mais comum e padrão para funções do Lambda. Neste exemplo, a função espera uma entrada semelhante à seguinte:

```
{
    "order_id": "12345",
    "amount": 199.99,
    "item": "Wireless Headphones"
}
```

Ao trabalhar com funções do Lambda em Go, é possível definir o formato do evento de entrada esperado como uma estrutura em Go. Neste exemplo, definimos uma estrutura para representar um `Order`:

```
type Order struct {
    OrderID string  `json:"order_id"`
    Amount  float64 `json:"amount"`
    Item    string  `json:"item"`
}
```

Essa estrutura corresponde ao formato de entrada esperado. Após definir a estrutura, você pode gravar uma assinatura de manipulador que aceita um tipo JSON genérico compatível com a [biblioteca padrão encoding/json](https://pkg.go.dev/encoding/json). Em seguida, é possível realizar a desserialização em sua estrutura ao usar a função [func Unmarshal](https://golang.org/pkg/encoding/json/#Unmarshal). Isso é ilustrado nas primeiras linhas do manipulador:

```
func handleRequest(ctx context.Context, event json.RawMessage) error {
    // Parse the input event
    var order Order
    if err := json.Unmarshal(event, &order); err != nil {
        log.Printf("Failed to unmarshal event: %v", err)
        return err
    ...
}
```

Após a desserialização, é possível acessar os campos da variável `order`. Por exemplo, `order.OrderID` recupera o valor de `"order_id"` da entrada original.

**nota**  
O pacote `encoding/json` tem acesso somente a campos que são exportados. Para serem exportados, os nomes do campo no struct do evento devem estar em letra maiúscula.

## Acesso e uso do objeto de contexto do Lambda
<a name="golang-example-context"></a>

O [objeto de contexto](golang-context.md) do Lambda contém informações sobre a invocação, a função e o ambiente de execução. Neste exemplo, declaramos essa variável como `ctx` na assinatura do manipulador:

```
func handleRequest(ctx context.Context, event json.RawMessage) error {
    ...
}
```

A entrada `ctx context.Context` é um argumento opcional em seu manipulador de função. Para obter mais informações sobre as assinaturas de manipulador aceitas, consulte [Assinaturas de manipulador válidas para manipuladores em Go](#golang-handler-signatures).

Se você realizar chamadas a outros serviços usando o AWS SDK, o objeto de contexto será necessário em algumas áreas importantes. Por exemplo, para inicializar corretamente os clientes do SDK, é possível carregar a configuração adequada do AWS SDK usando o objeto de contexto da seguinte maneira:

```
// Load AWS SDK configuration using the default credential provider chain
    cfg, err := config.LoadDefaultConfig(ctx)
```

As próprias chamadas do SDK podem exigir o objeto de contexto como um parâmetro de entrada. Por exemplo, a chamada `s3Client.PutObject` aceita o objeto de contexto como seu primeiro argumento:

```
// Upload the receipt to S3
    _, err = s3Client.PutObject(ctx, &s3.PutObjectInput{
        ...
    })
```

Além das solicitações do AWS SDK, é possível usar o objeto de contexto para realizar o monitoramento da função. Para obter mais informações sobre o objeto de contexto, consulte [Usar o objeto de contexto do Lambda para recuperar informações das funções em Go](golang-context.md).

## Assinaturas de manipulador válidas para manipuladores em Go
<a name="golang-handler-signatures"></a>

Há várias opções ao criar um manipulador de função do Lambda no Go, mas você deve observar as seguintes regras:
+ O manipulador deve ser uma função.
+ O manipulador pode usar de 0 a 2 argumentos. Se houver dois argumentos, o primeiro argumento deverá implementar `context.Context`.
+ O manipulador pode retornar de 0 a 2 argumentos. Se houver um único valor de retorno, ele deverá implementar `error`. Se houver dois valores de retorno, o segundo valor deverá implementar `error`.

As assinaturas válidas de manipulador são listadas a seguir. `TIn` e `TOut` representam tipos compatíveis com a biblioteca *encoding/json* padrão. Para obter mais informações, consulte [func Unmarshal](https://golang.org/pkg/encoding/json/#Unmarshal) para saber como esses tipos são desserializados.
+ 

  ```
  func ()
  ```
+ 

  ```
  func () error
  ```
+ 

  ```
  func () (TOut, error)
  ```
+ 

  ```
  func (TIn) error
  ```
+ 

  ```
  func (TIn) (TOut, error)
  ```
+ 

  ```
  func (context.Context) error
  ```
+ 

  ```
  func (context.Context) (TOut, error)
  ```
+ 

  ```
  func (context.Context, TIn) error
  ```
+ 

  ```
  func (context.Context, TIn) (TOut, error)
  ```

## Uso do AWS SDK para Go v2 em seu manipulador
<a name="golang-example-sdk-usage"></a>

Frequentemente, você usará as funções do Lambda para interagir com ou fazer atualizações em outros recursos da AWS. A maneira mais simples de interagir com esses recursos é usar o [AWS SDK para Go v2](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2).

**nota**  
O AWS SDK para Go (v1) está em modo de manutenção e terá o suporte encerrado em 31 de julho de 2025. Recomendamos que você use somente o AWS SDK para Go v2 daqui em diante.

Para adicionar as dependências do SDK à sua função, use o comando `go get` para os clientes específicos do SDK que você precisa. No código de exemplo anterior, usamos a biblioteca `config` e a biblioteca `s3`. Adicione essas dependências ao executar os seguintes comandos no diretório que contém seus arquivos `go.mod` e `main.go `:

```
go get github.com/aws/aws-sdk-go-v2/config
go get github.com/aws/aws-sdk-go-v2/service/s3
```

Em seguida, importe as dependências correspondentes no bloco “import” da sua função:

```
import (
    ...
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/s3"
)
```

Ao usar o SDK no seu manipulador, configure os clientes com as configurações adequadas. A maneira mais simples de fazer isso é usar a [cadeia de provedores de credenciais padrão](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html#credentialProviderChain). Este exemplo ilustra uma forma de carregar essa configuração:

```
// Load AWS SDK configuration using the default credential provider chain
    cfg, err := config.LoadDefaultConfig(ctx)
    if err != nil {
        log.Printf("Failed to load AWS SDK config: %v", err)
        return err
    }
```

Após carregar essa configuração na variável `cfg`, você pode fornecê-la nas instâncias dos clientes. No exemplo, o código cria uma instância de cliente do Amazon S3 da seguinte maneira:

```
// Create an S3 client
    s3Client := s3.NewFromConfig(cfg)
```

Neste exemplo, inicializamos nosso cliente do Amazon S3 na função `init()` para evitar a necessidade de inicializá-lo a cada vez que nossa função é invocada. O problema é que, na função `init()`, o Lambda não tem acesso ao objeto de contexto. Como solução alternativa, você pode fornecer um espaço reservado, como `context.TODO()`, durante a fase de inicialização. Posteriormente, ao fazer uma chamada usando o cliente, forneça o objeto de contexto completo. Esta solução alternativa também é descrita em [Uso do contexto nas inicializações e nas chamadas do cliente do AWS SDK](golang-context.md#golang-context-sdk).

Após configurar e inicializar o cliente do SDK, você pode usá-lo para interagir com outros serviços da AWS. O código de exemplo chama a API `PutObject` do Amazon S3 da seguinte forma:

```
_, err = s3Client.PutObject(ctx, &s3.PutObjectInput{
    Bucket: &bucketName,
    Key:    &key,
    Body:   strings.NewReader(receiptContent),
})
```

## Acesso a variáveis de ambiente
<a name="golang-example-envvars"></a>

No código do manipulador, você pode fazer referência a qualquer [variável de ambiente](configuration-envvars.md) ao usar o método `os.Getenv()`. Neste exemplo, referenciamos a variável de ambiente `RECEIPT_BUCKET` definida usando a seguinte linha de código:

```
// Access environment variables
    bucketName := os.Getenv("RECEIPT_BUCKET")
    if bucketName == "" {
        log.Printf("RECEIPT_BUCKET environment variable is not set")
        return fmt.Errorf("missing required environment variable RECEIPT_BUCKET")
    }
```

## Usar o estado global
<a name="golang-handler-state"></a>

Para evitar a criação de novos recursos a cada vez que você invoca a função, é possível declarar e modificar variáveis globais externas ao código do manipulador da função do Lambda. Defina essas variáveis globais em um bloco ou em uma instrução em `var`. Além disso, o manipulador pode declarar uma função `init()` que é executada durante a [fase de inicialização](lambda-runtime-environment.md#runtimes-lifecycle-ib). No AWS Lambda, o método `init` se comporta de maneira idêntica aos programas em Go padrão.

## Práticas recomendadas de código para as funções do Lambda em GO
<a name="go-best-practices"></a>

Adote as diretrizes da lista a seguir para usar as práticas recomendadas de codificação ao compilar suas funções do Lambda:
+ **Separe o manipulador do Lambda da lógica central.** Isso permite que você crie uma função mais fácil para teste de unidade.
+ **Minimize a complexidade de suas dependências.** Prefira frameworks mais simples que sejam carregados rapidamente no startup do [ambiente de execução](lambda-runtime-environment.md).
+ **Minimize o tamanho do pacote de implantação para conter somente o necessário para o runtime.** Isso reduzirá a quantidade de tempo necessária para que seu pacote de implantação seja obtido por download e desempacotado antes da invocação.

**Aproveite a reutilização do ambiente de execução para melhorar a performance da função.** Inicialize clientes SDK e conexões de banco de dados fora do manipulador de funções e armazene em cache os ativos estáticos localmente no diretório `/tmp`. As invocações subsequentes processadas pela mesma instância da função podem reutilizar esses recursos. Isso economiza custos reduzindo o runtime da função.

Para evitar possíveis vazamentos de dados entre invocações, não use o ambiente de execução para armazenar dados do usuário, eventos ou outras informações com implicações de segurança. Se sua função depende de um estado mutável que não pode ser armazenado na memória dentro do manipulador, considere criar uma função separada ou versões separadas de uma função para cada usuário.

**Use uma diretiva de keep-alive para manter conexões persistentes.** O Lambda limpa conexões ociosas ao longo do tempo. A tentativa de reutilizar uma conexão ociosa ao invocar uma função resultará em um erro de conexão. Para manter sua conexão persistente, use a diretiva keep-alive associada ao runtime. Para obter um exemplo, consulte [Reutilizar conexões com keep-alive em Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html).

**Use [variáveis de ambiente](configuration-envvars.md) para passar parâmetros operacionais para sua função.** Por exemplo, se estiver gravando em um bucket do Amazon S3, em vez fixar no código o nome do bucket em que você está gravando, configure o nome do bucket como uma variável de ambiente.

**Evite usar invocações recursivas** em sua função do Lambda, em que a função invoca a si mesma ou inicia um processo que pode invocar a função novamente. Isso pode levar a um volume não intencional de invocações da função e a custos elevados. Se você observar um volume não intencional de invocações, defina a simultaneidade reservada da função como `0` imediatamente para limitar todas as invocações da função enquanto atualiza o código.

**Não use APIs não documentadas e não públicas** no código da função Lambda. Para os tempos de execução gerenciados pelo AWS Lambda, o Lambda aplica periodicamente atualizações funcionais e de segurança às APIs internas do Lambda. Essas atualizações internas da API podem ser incompatíveis com versões anteriores, gerando consequências não intencionais, como falhas de invocação, caso sua função tenha dependência nessas APIs não públicas. Consulte [a referência da API](https://docs.aws.amazon.com/lambda/latest/api/welcome.html) para obter uma lista de APIs disponíveis publicamente.

**Escreva um código idempotente.** Escrever um código idempotente para suas funções garante que eventos duplicados sejam tratados da mesma maneira. Seu código deve validar eventos adequadamente e lidar corretamente com eventos duplicados. Para obter mais informações, consulte [Como torno minha função do Lambda idempotente?](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-function-idempotent/).

# Usar o objeto de contexto do Lambda para recuperar informações das funções em Go
<a name="golang-context"></a>

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 name="golang-context-library"></a>

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
<a name="golang-context-access"></a>

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
<a name="golang-context-sdk"></a>

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.

# Implantar funções do Lambda em Go com arquivos .zip
<a name="golang-package"></a>

O código da função do AWS Lambda consiste em scripts ou programas compilados e as dependências deles. Você usa um*pacote de implantação*para implantar seu código de função no Lambda. O Lambda é compatível com dois tipos de pacotes de implantação: imagens de contêiner e arquivos .zip. 

Esta página descreve como criar um arquivo .zip como seu pacote de implantação do runtime do Go e, em seguida, usar o arquivo para implantar o código de sua função no AWS Lambda utilizando o Console de gerenciamento da AWS, o AWS Command Line Interface, a (AWS CLI) e o AWS Serverless Application Model (AWS SAM).

Observe que o Lambda usa permissões de arquivo POSIX, então pode ser necessário [definir permissões para a pasta do pacote de implantação](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-deployment-package-errors/) antes da criação do arquivo .zip.

**Topics**
+ [

## Criando um arquivo .zip no macOS e no Linux
](#golang-package-mac-linux)
+ [

## Criando um arquivo .zip no Windows
](#golang-package-windows)
+ [

## Criar e atualizar funções do Lambda em Go usando arquivos .zip
](#golang-package-create-function)

## Criando um arquivo .zip no macOS e no Linux
<a name="golang-package-mac-linux"></a>

As etapas a seguir mostram como compilar o executável usando o comando `go build` e criar um pacote de implantação do arquivo .zip para o Lambda. Antes de compilar seu código, verifique se você instalou o pacote [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda) do GitHub. Este módulo fornece uma implementação da interface de runtime, que gerencia a interação entre o Lambda e seu código da função. Para baixar essa biblioteca, execute o comando a seguir.

```
go get github.com/aws/aws-lambda-go/lambda
```

Se sua função usa o AWS SDK para Go, baixe o conjunto padrão de módulos do SDK e qualquer cliente de API de serviço da AWS exigido pela sua aplicação. Para saber como instalar o SDK para Go, consulte [Conceitos básicos do AWS SDK para Go V2](https://github.com/aws/aws-sdk-go-v2?tab=readme-ov-file#getting-started).

### Usar o runtime da família fornecido
<a name="golang-package-mac-linux-al2"></a>

O Go é implementado de forma diferente de outros runtimes gerenciados. Como o Go é compilado nativamente com um binário executável, ele não requer um runtime de linguagem dedicado. Use um [runtime somente de sistema operacional](runtimes-provided.md) (a família de runtime `provided`) para implantar funções do Go no Lambda.

**Para criar um pacote de implantação de arquivo .zip (macOs/Linux)**

1. No diretório do projeto que contém o arquivo `main.go` da sua aplicação, compile seu executável. Observe o seguinte:
   + O executável deve ser nomeado `bootstrap`. Para obter mais informações, consulte [Convenções de nomenclatura para manipuladores](golang-handler.md#golang-handler-naming).
   + Defina sua [arquitetura do conjunto de instruções](foundation-arch.md) de destino. Os runtimes somente de SO são compatíveis com arm64 e x86\$164.
   + Você pode usar a tag `lambda.norpc` opcional para excluir o componente Remote Procedure Call (RPC) da biblioteca do [Lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda). O componente RPC só será necessário se você estiver usando o runtime do Go 1.x. descontinuado. A exclusão do RPC reduz o tamanho do pacote de implantação.

   Para a arquitetura arm64:

   ```
   GOOS=linux GOARCH=arm64 go build -tags lambda.norpc -o bootstrap main.go
   ```

   Para a arquitetura x86\$164:

   ```
   GOOS=linux GOARCH=amd64 go build -tags lambda.norpc -o bootstrap main.go
   ```

1. (Opcional) Talvez seja necessário compilar pacotes com o `CGO_ENABLED=0` configurado no Linux:

   ```
   GOOS=linux GOARCH=arm64 CGO_ENABLED=0 go build -o bootstrap -tags lambda.norpc main.go
   ```

   Este comando cria um pacote binário estável para versões padrão da biblioteca C (`libc`), que podem ser diferentes no Lambda e em outros dispositivos.

1. Crie um pacote de implantação empacotando o executável em um arquivo .zip.

   ```
   zip myFunction.zip bootstrap
   ```
**nota**  
O arquivo `bootstrap` deve estar na raiz do arquivo .zip.

1. Criar a função do Observe o seguinte:
   + O binário deve ser chamado de `bootstrap`, mas o nome do manipulador pode ser qualquer coisa. Para obter mais informações, consulte [Convenções de nomenclatura para manipuladores](golang-handler.md#golang-handler-naming).
   + A opção `--architectures` será necessária apenas se você estiver usando arm64. O valor padrão é x86\$164.
   + Para `--role`, especifique o nome do recurso da Amazon (ARN) da [função de execução](lambda-intro-execution-role.md).

   ```
   aws lambda create-function --function-name myFunction \
   --runtime provided.al2023 --handler bootstrap \
   --architectures arm64 \
   --role arn:aws:iam::111122223333:role/lambda-ex \
   --zip-file fileb://myFunction.zip
   ```

## Criando um arquivo .zip no Windows
<a name="golang-package-windows"></a>

As etapas a seguir mostram como baixar a ferramenta [build-lambda-zip](https://github.com/aws/aws-lambda-go/tree/main/cmd/build-lambda-zip) para Windows do GitHub, compilar seu executável e criar um pacote de implantação .zip.

**nota**  
Se ainda não tiver feito isso, você precisará instalar o [Git](https://git-scm.com/) e, em seguida, adicionar o executável `git` à variável de ambiente `%PATH%` do Windows.

Antes de compilar o código, verifique se você instalou a biblioteca [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda) do GitHub. Para baixar essa biblioteca, execute o comando a seguir.

```
go get github.com/aws/aws-lambda-go/lambda
```

Se sua função usa o AWS SDK para Go, baixe o conjunto padrão de módulos do SDK e qualquer cliente de API de serviço da AWS exigido pela sua aplicação. Para saber como instalar o SDK para Go, consulte [Conceitos básicos do AWS SDK para Go V2](https://aws.github.io/aws-sdk-go-v2/docs/getting-started/).

### Usar o runtime da família fornecido
<a name="golang-package-windows-al2"></a>

O Go é implementado de forma diferente de outros runtimes gerenciados. Como o Go é compilado nativamente com um binário executável, ele não requer um runtime de linguagem dedicado. Use um [runtime somente de sistema operacional](runtimes-provided.md) (a família de runtime `provided`) para implantar funções do Go no Lambda.

**Para criar um pacote de implantação .zip (Windows)**

1. Faça download da ferramenta **build-lambda-zip** do GitHub.

   ```
   go install github.com/aws/aws-lambda-go/cmd/build-lambda-zip@latest
   ```

1. Use a ferramenta do seu `GOPATH` para criar um arquivo .zip. Se você tiver uma instalação padrão do Go, a ferramenta geralmente estará em `%USERPROFILE%\Go\bin`. Caso contrário, navegue até o local em que o runtime do Go foi instalado e faça o seguinte:

------
#### [ cmd.exe ]

   Em cmd.exe, execute uma das seguintes ações, dependendo da sua [arquitetura do conjunto de instruções](foundation-arch.md) de destino. Os runtimes somente de SO são compatíveis com arm64 e x86\$164.

   Você pode usar a tag `lambda.norpc` opcional para excluir o componente Remote Procedure Call (RPC) da biblioteca do [Lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda). O componente RPC só será necessário se você estiver usando o runtime do Go 1.x. descontinuado. A exclusão do RPC reduz o tamanho do pacote de implantação.

**Example : para a arquitetura x86\$164**  

   ```
   set GOOS=linux
   set GOARCH=amd64
   set CGO_ENABLED=0
   go build -tags lambda.norpc -o bootstrap main.go
   %USERPROFILE%\Go\bin\build-lambda-zip.exe -o myFunction.zip bootstrap
   ```

**Example : para a arquitetura arm64**  

   ```
   set GOOS=linux
   set GOARCH=arm64
   set CGO_ENABLED=0
   go build -tags lambda.norpc -o bootstrap main.go
   %USERPROFILE%\Go\bin\build-lambda-zip.exe -o myFunction.zip bootstrap
   ```

------
#### [ PowerShell ]

   No PowerShell, execute uma das seguintes ações, dependendo da sua [arquitetura do conjunto de instruções](foundation-arch.md) de destino. Os runtimes somente de SO são compatíveis com arm64 e x86\$164.

   Você pode usar a tag `lambda.norpc` opcional para excluir o componente Remote Procedure Call (RPC) da biblioteca do [Lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda). O componente RPC só será necessário se você estiver usando o runtime do Go 1.x. descontinuado. A exclusão do RPC reduz o tamanho do pacote de implantação.

   Para a arquitetura x86\$164:

   ```
   $env:GOOS = "linux"
   $env:GOARCH = "amd64"
   $env:CGO_ENABLED = "0"
   go build -tags lambda.norpc -o bootstrap main.go
   ~\Go\Bin\build-lambda-zip.exe -o myFunction.zip bootstrap
   ```

   Para a arquitetura arm64:

   ```
   $env:GOOS = "linux"
   $env:GOARCH = "arm64"
   $env:CGO_ENABLED = "0"
   go build -tags lambda.norpc -o bootstrap main.go
   ~\Go\Bin\build-lambda-zip.exe -o myFunction.zip bootstrap
   ```

------

1. Criar a função do Observe o seguinte:
   + O binário deve ser chamado de `bootstrap`, mas o nome do manipulador pode ser qualquer coisa. Para obter mais informações, consulte [Convenções de nomenclatura para manipuladores](golang-handler.md#golang-handler-naming).
   + A opção `--architectures` será necessária apenas se você estiver usando arm64. O valor padrão é x86\$164.
   + Para `--role`, especifique o nome do recurso da Amazon (ARN) da [função de execução](lambda-intro-execution-role.md).

   ```
   aws lambda create-function --function-name myFunction \
   --runtime provided.al2023 --handler bootstrap \
   --architectures arm64 \
   --role arn:aws:iam::111122223333:role/lambda-ex \
   --zip-file fileb://myFunction.zip
   ```

## Criar e atualizar funções do Lambda em Go usando arquivos .zip
<a name="golang-package-create-function"></a>

 Depois de criar o pacote de implantação .zip, você poderá usá-lo para criar uma função do Lambda ou atualizar uma existente. É possível implantar o pacote .zip usando o console do Lambda, a AWS Command Line Interface e a API do Lambda. Você também pode criar e atualizar funções do Lambda usando o AWS Serverless Application Model (AWS SAM) e o CloudFormation. 

O tamanho máximo de um pacote de implantação .zip para o Lambda é 250 MB (descompactado). Esse limite se aplica ao tamanho combinado de todos os arquivos que você carrega, inclusive qualquer camada do Lambda.

O runtime do Lambda precisa de permissão para ler os arquivos no pacote de implantação. Na notação octal de permissões do Linux, o Lambda precisa de 644 permissões para arquivos não executáveis (rw-r--r--) e 755 permissões (rwxr-xr-x) para diretórios e arquivos executáveis.

No Linux e no MacOS, use o comando `chmod` para alterar as permissões de arquivo em arquivos e diretórios do seu pacote de implantação. Por exemplo, para dar a um arquivo não executável as permissões corretas, execute o comando a seguir.

```
chmod 644 <filepath>
```

Para alterar as permissões de arquivo no Windows, consulte [Set, View, Change, or Remove Permissions on an Object](https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc731667(v=ws.10)) na documentação do Microsoft Windows.

**nota**  
Se você não conceder ao Lambda as permissões necessárias para acessar diretórios no seu pacote de implantação, o Lambda definirá as permissões desses diretórios como 755 (rwxr-xr-x).

### Criar e atualizar funções com arquivos .zip usando o console
<a name="golang-package-create-console"></a>

 Para criar uma nova função, você deve primeiro criar a função no console e depois carregar o arquivo .zip. Para atualizar uma função existente, abra a página da função e siga o mesmo procedimento para adicionar o arquivo .zip atualizado. 

 Se o arquivo .zip for menor que 50 MB, você poderá criar ou atualizar uma função carregando o arquivo diretamente da máquina local. Para arquivos .zip maiores que 50 MB, você deve primeiro carregar o pacote para um bucket do Amazon S3. Para obter instruções sobre como carregar um arquivo para um bucket do Amazon S3 usando o Console de gerenciamento da AWS, consulte [Conceitos básicos do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html). Para carregar arquivos usando a AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) no *Guia do usuário da AWS CLI*. 

**nota**  
Não é possível converter uma função de imagem de contêiner existente para usar um arquivo .zip. É necessário criar uma nova função.

**Para criar uma função (console)**

1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda e escolha **Criar função**.

1. Escolha **Author from scratch** (Criar do zero).

1. Em **Basic information** (Informações básicas), faça o seguinte:

   1. Em **Nome da função**, insira o nome da função.

   1. Em **Runtime (Tempo de execução)**, escolha `provided.al2023`.

1. (Opcional) Em **Permissões**, expanda **Alterar função de execução padrão**. Crie uma **função de execução** ou use uma existente.

1. Escolha a opção **Criar função**. O Lambda cria uma função básica “Hello world” usando o runtime escolhido.

**Você pode carregar o arquivo .zip da máquina local (console)**

1. Na [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console Lambda, escolha a função para a qual você deseja carregar o arquivo .zip.

1. Selecione a guia **Código**.

1. No painel do **Código-fonte**, escolha **Carregar de**.

1. Escolha o **arquivo .zip**.

1. Para carregar o arquivo .zip, faça o seguinte:

   1. Selecione **Carregar** e, em seguida, selecione o arquivo .zip no seletor de arquivos.

   1. Escolha **Open (Abrir)**.

   1. Escolha **Salvar**.

**Para carregar um arquivo .zip de um bucket do Amazon S3 (console)**

1. Na [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda, escolha a função para a qual você deseja carregar um novo arquivo .zip.

1. Selecione a guia **Código**.

1. No painel do **Código-fonte**, escolha **Carregar de**.

1. Escolha **Local do Amazon S3**.

1. Cole o URL do link do Amazon S3 do arquivo .zip e escolha **Salvar**.

### Criar e atualizar funções com arquivos .zip usando a AWS CLI
<a name="golang-package-create-cli"></a>

 Você pode usar a [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) para criar uma função ou atualizar uma existente usando um arquivo .zip. Use os comandos [create-function](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) e [update-function-code](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) para implantar o pacote .zip. Se o arquivo .zip for menor que 50 MB, você poderá carregar o pacote .zip de um local do arquivo na máquina de compilação local. Para arquivos .zip maiores, você deve carregar o pacote .zip de um bucket do Amazon S3. Para obter instruções sobre como carregar um arquivo para um bucket do Amazon S3 usando a AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) no *Guia do usuário da AWS CLI*. 

**nota**  
Se você carregar o arquivo .zip de um bucket do Amazon S3 usando a AWS CLI, o bucket deverá estar na mesma Região da AWS que sua função.

 Para criar uma função usando um arquivo .zip com a AWS CLI, você deve especificar o seguinte: 
+ O nome da função (`--function-name`)
+ O runtime da função (`--runtime`)
+ O nome do recurso da Amazon (ARN) da [função de execução](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) da função (`--role`)
+ O nome do método do manipulador no código da função (`--handler`)

 Você também deve especificar a local do arquivo .zip. Se o arquivo .zip estiver localizado em uma pasta da máquina de compilação local, use a opção `--zip-file` para especificar o caminho do arquivo, conforme mostrado no comando do exemplo a seguir. 

```
aws lambda create-function --function-name myFunction \
--runtime provided.al2023 --handler bootstrap \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--zip-file fileb://myFunction.zip
```

 Para especificar o local do arquivo .zip em um bucket do Amazon S3, use a opção `--code` conforme mostrado no comando do exemplo a seguir. Você só precisa usar o parâmetro `S3ObjectVersion` para objetos com versionamento. 

```
aws lambda create-function --function-name myFunction \
--runtime provided.al2023 --handler bootstrap \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion
```

 Para atualizar uma função existente usando a CLI, especifique o nome da função usando o parâmetro `--function-name`. Você também deve especificar o local do arquivo .zip que deseja usar para atualizar o código da função. Se o arquivo .zip estiver localizado em uma pasta da máquina de compilação local, use a opção `--zip-file` para especificar o caminho do arquivo, conforme mostrado no comando do exemplo a seguir. 

```
aws lambda update-function-code --function-name myFunction \
--zip-file fileb://myFunction.zip
```

 Para especificar o local do arquivo .zip em um bucket do Amazon S3, use as opções `--s3-bucket` e `--s3-key` conforme mostrado no comando do exemplo a seguir. Você só precisa usar o parâmetro `--s3-object-version` para objetos com versionamento. 

```
aws lambda update-function-code --function-name myFunction \
--s3-bucket amzn-s3-demo-bucket --s3-key myFileName.zip --s3-object-version myObject Version
```

### Criar e atualizar funções com arquivos .zip usando a API do Lamba
<a name="golang-package-create-api"></a>

 Para criar e atualizar funções usando um arquivo .zip, use as seguintes operações de API: 
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionCode.html)

### Criar e atualizar funções com arquivos .zip usando o AWS SAM
<a name="golang-package-create-sam"></a>

 O AWS Serverless Application Model (AWS SAM) é um kit de ferramentas que ajuda a simplificar o processo de criação e execução de aplicações com tecnologia sem servidor na AWS. Você define os recursos para a aplicação em um modelo YAML ou JSON e usa a interface da linha de comando do AWS SAM (CLI do AWS SAM) para criar, empacotar e implantar aplicações. Quando você cria uma função do Lambda com base em um modelo do AWS SAM, o AWS SAM cria automaticamente um pacote de implantação .zip ou uma imagem de contêiner com o código da função e quaisquer dependências que você especificar. Para saber mais sobre como usar o AWS SAM para criar e implantar funções do Lambda, consulte [Conceitos básicos do AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) no *Guia do desenvolvedor do AWS Serverless Application Model*.

Você também pode usar o AWS SAM para criar uma função do Lambda usando um arquivo .zip existente. Para criar uma função do Lambda usando o AWS SAM, salve o arquivo .zip em um bucket do Amazon S3 ou em uma pasta local na máquina de compilação. Para obter instruções sobre como carregar um arquivo para um bucket do Amazon S3 usando a AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) no *Guia do usuário da AWS CLI*. 

 No modelo do AWS SAM, o recurso `AWS::Serverless::Function` especifica a função do Lambda. Nesse recurso, defina as seguintes propriedades para criar uma função usando um arquivo .zip: 
+ `PackageType`: definir como `Zip`
+ `CodeUri`: definir como o URI do Amazon S3 do código da função, o caminho para a pasta local ou o objeto [FunctionCode](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-functioncode.html)
+ `Runtime`: definir como o runtime escolhido

 Com o AWS SAM, se o arquivo .zip for maior que 50 MB, você não precisará carregá-lo primeiro em um bucket do Amazon S3. O AWS SAM poderá carregar pacotes .zip com o tamanho máximo permitido de 250 MB (descompactados) de um local da máquina de compilação local. 

 Para saber mais sobre a implantação de funções usando o arquivo .zip no AWS SAM, consulte [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html) no *Guia do desenvolvedor do AWS SAM*. 

**Exemplo: usar o AWS SAM para criar uma função do Go com provided.al2023**

1. Crie um modelo do AWS SAM com as seguintes propriedades:
   + **BuildMethod**: especifica o compilador para sua aplicação. Use `go1.x`.
   + **Runtime**: use `provided.al2023`.
   + **CodeUri**: insira o caminho para seu código.
   + **Arquiteturas**: use `[arm64]` para a arquitetura arm64. Para a arquitetura do conjunto de instruções x86\$164, use `[amd64]` ou remova a propriedade `Architectures`.  
**Example template.yaml**  

   ```
   AWSTemplateFormatVersion: '2010-09-09'
   Transform: 'AWS::Serverless-2016-10-31'
   Resources:
     HelloWorldFunction:
       Type: AWS::Serverless::Function
       Metadata:
         BuildMethod: go1.x
       Properties:
         CodeUri: hello-world/ # folder where your main program resides
         Handler: bootstrap
         Runtime: provided.al2023
         Architectures: [arm64]
   ```

1. Use o comando [sam build](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-build.html) para compilar o executável.

   ```
   sam build
   ```

1. Use o comando [sam deploy](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html) para implantar a função no Lambda.

   ```
   sam deploy --guided
   ```

### Criar e atualizar funções com arquivos .zip usando o CloudFormation
<a name="golang-package-create-cfn"></a>

 Você pode usar o CloudFormation para criar uma função do Lambda usando um arquivo .zip. Para criar uma função do Lambda de um arquivo.zip, primeiro carregue o arquivo em um bucket do Amazon S3. Para obter instruções sobre como carregar um arquivo para um bucket do Amazon S3 usando a AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) no *Guia do usuário da AWS CLI. *

No modelo do CloudFormation, o recurso `AWS::Lambda::Function` especifica a função do Lambda. Nesse recurso, defina as seguintes propriedades para criar uma função usando um arquivo .zip:
+ `PackageType`: definir como `Zip`
+ `Code`: inserir o nome do bucket do Amazon S3 e o nome do arquivo .zip nos campos `S3Bucket` e `S3Key`
+ `Runtime`: definir como o runtime escolhido

 O arquivo .zip que o CloudFormation gera não pode exceder 4 MB. Para saber mais sobre a implantação de funções usando o arquivo .zip no CloudFormation, consulte [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html) no *Guia do desenvolvedor do CloudFormation*. 

# Implantar funções do Lambda em Go com imagens de contêiner
<a name="go-image"></a>

Existem duas maneiras de criar uma imagem de contêiner para uma função do Lambda do Go:
+ [Usar uma imagem base somente para sistema operacional da AWS](#go-image-provided)

  O Go é implementado de forma diferente de outros runtimes gerenciados. Como o Go é compilado nativamente com um binário executável, ele não requer um runtime de linguagem dedicado. Use uma [imagem de base somente do sistema operacional](images-create.md#runtimes-images-provided) para criar imagens do Go para o Lambda. Para tornar a imagem compatível com o Lambda, você deve incluir o pacote `aws-lambda-go/lambda` na imagem.
+ [Usar uma imagem base que não é da AWS](#go-image-other)

  Você também pode usar uma imagem base alternativa de outro registro de contêiner, como Alpine Linux ou Debian. Você também pode usar uma imagem personalizada criada por sua organização. Para tornar a imagem compatível com o Lambda, você deve incluir o pacote `aws-lambda-go/lambda` na imagem.

**dica**  
Para reduzir o tempo necessário para que as funções do contêiner do Lambda se tornem ativas, consulte [Use multi-stage builds](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#use-multi-stage-builds) na documentação do Docker. Para criar imagens de contêiner eficientes, siga as [Melhores práticas para gravar Dockerfiles](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).

Esta página explica como criar, testar e implantar imagens de contêiner para o Lambda.

## Imagens de base da AWS para implantar funções do Go
<a name="go-image-base"></a>

O Go é implementado de forma diferente de outros runtimes gerenciados. Como o Go é compilado nativamente com um binário executável, ele não requer um runtime de linguagem dedicado. Use uma [imagem de base somente do sistema operacional](images-create.md#runtimes-images-provided) para implantar funções do Go no Lambda.


| Nome | Identificador | Sistema operacional | Data da substituição | Bloquear a criação de funções | Bloquear a atualização de funções | 
| --- | --- | --- | --- | --- | --- | 
|  Runtime somente para sistema operacional  |  `provided.al2023`  |  Amazon Linux 2023  |   30 de junho de 2029   |   31 de julho de 2029   |   31 de agosto de 2029   | 
|  Runtime somente para sistema operacional  |  `provided.al2`  |  Amazon Linux 2  |   31 de julho de 2026   |   31 de agosto de 2026   |   30 de setembro de 2026   | 

Galeria pública do Amazon Elastic Container Registry: [gallery.ecr.aws/lambda/provided](https://gallery.ecr.aws/lambda/provided)

## Clientes de interface de runtime do Go
<a name="go-image-clients"></a>

O pacote `aws-lambda-go/lambda` inclui uma implementação da interface de runtime. Para obter exemplos de como usar `aws-lambda-go/lambda` na sua imagem, consulte [Usar uma imagem base somente para sistema operacional da AWS](#go-image-provided) ou [Usar uma imagem base que não é da AWS](#go-image-other).

## Usar uma imagem base somente para sistema operacional da AWS
<a name="go-image-provided"></a>

O Go é implementado de forma diferente de outros runtimes gerenciados. Como o Go é compilado nativamente com um binário executável, ele não requer um runtime de linguagem dedicado. Use uma [imagem de base somente do sistema operacional](images-create.md#runtimes-images-provided) para criar imagens de contêiner para as funções do Go.


| Tags | Runtime | Sistema operacional | Dockerfile | Desaprovação | 
| --- | --- | --- | --- | --- | 
| al2023 | Runtime somente para sistema operacional | Amazon Linux 2023 | [Dockerfile para runtime somente para sistema operacional no GitHub](https://github.com/aws/aws-lambda-base-images/blob/provided.al2023/Dockerfile.provided.al2023) |   30 de junho de 2029   | 
| al2 | Runtime somente para sistema operacional | Amazon Linux 2 | [Dockerfile para runtime somente para sistema operacional no GitHub](https://github.com/aws/aws-lambda-base-images/blob/provided.al2/Dockerfile.provided.al2) |   31 de julho de 2026   | 

Para obter mais informações sobre esta imagem base, consulte [fornecido](https://gallery.ecr.aws/lambda/provided) na galeria pública do Amazon ECR.

Você deve incluir o pacote [aws-lambda-go/lambda](https://github.com/aws/aws-lambda-go) com seu manipulador de Go. Esse pacote implementa o modelo de programação para Go, incluindo a interface de runtime.

### Pré-requisitos
<a name="go-custom-prerequisites"></a>

Para executar as etapas desta seção, você deve ter o seguinte:
+ [AWS CLI versão 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versão mínima 25.0.0)
+ O plug-in [buildx](https://github.com/docker/buildx/blob/master/README.md) do Docker.
+ Go

### Criar uma imagem baseada na imagem base provided.al2023
<a name="go-custom-create"></a>

**Criar e implantar uma função do Go com a imagem base `provided.al2023`**

1. Crie um diretório para o projeto e depois mude para esse diretório.

   ```
   mkdir hello
   cd hello
   ```

1. Inicialize um novo módulo do Go.

   ```
   go mod init example.com/hello-world
   ```

1. Adicione a biblioteca **lambda** como uma dependência do seu novo módulo.

   ```
   go get github.com/aws/aws-lambda-go/lambda
   ```

1. Crie um arquivo denominado `main.go` e abra-o em um editor de texto. Este é o código da função  do Lambda. É possível usar o código de exemplo a seguir para fins de teste ou substituí-lo pelo seu próprio código.

   ```
   package main
   
   import (
   	"context"
   	"github.com/aws/aws-lambda-go/events"
   	"github.com/aws/aws-lambda-go/lambda"
   )
   
   func handler(ctx context.Context, event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
   	response := events.APIGatewayProxyResponse{
   		StatusCode: 200,
   		Body:       "\"Hello from Lambda!\"",
   	}
   	return response, nil
   }
   
   func main() {
   	lambda.Start(handler)
   }
   ```

1. Use um editor de texto para criar um Dockerfile no diretório do projeto.
   + O exemplo de Dockerfile a seguir usa uma [compilação em várias etapas](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#use-multi-stage-builds). Isso permite que você use uma imagem base diferente em cada etapa. É possível usar uma imagem, como uma [imagem base Go](https://hub.docker.com/_/golang), para compilar seu código e construir o binário executável. Em seguida, é possível usar uma imagem diferente, como `provided.al2023`, na declaração `FROM` final, para definir a imagem implantada no Lambda. O processo de construção é separado da imagem final de implantação, portanto, a imagem final contém apenas os arquivos necessários para executar a aplicação.
   + Você pode usar a tag `lambda.norpc` opcional para excluir o componente Remote Procedure Call (RPC) da biblioteca do [Lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda). O componente RPC só será necessário se você estiver usando o runtime do Go 1.x. descontinuado. A exclusão do RPC reduz o tamanho do pacote de implantação.
   + Observe que o Dockerfile de exemplo não inclui uma [instrução USER](https://docs.docker.com/reference/dockerfile/#user). Quando você implanta uma imagem de contêiner no Lambda, o Lambda define automaticamente um usuário padrão do Linux com permissões de privilégio mínimo. Isso é diferente do comportamento padrão do Docker, que adota o usuário `root` como padrão quando nenhuma instrução `USER` é fornecida.  
**Example — Dockerfile de construção em vários estágios**  
**nota**  
Certifique-se de que a versão do Go que você especifica em seu Dockerfile (por exemplo, `golang:1.20`) seja a mesma versão do Go que você usou para criar sua aplicação.

   ```
   FROM golang:1.20 as build
   WORKDIR /helloworld
   # Copy dependencies list
   COPY go.mod go.sum ./
   # Build with optional lambda.norpc tag
   COPY main.go .
   RUN go build -tags lambda.norpc -o main main.go
   # Copy artifacts to a clean image
   FROM public.ecr.aws/lambda/provided:al2023
   COPY --from=build /helloworld/main ./main
   ENTRYPOINT [ "./main" ]
   ```

1. Crie a imagem do Docker com o comando [docker build](https://docs.docker.com/engine/reference/commandline/build/). O exemplo a seguir nomeia a imagem como `docker-image` e atribui a ela a [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) `test`. Para tornar sua imagem compatível com o Lambda, é necessário usar a opção `--provenance=false`.

   ```
   docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
   ```
**nota**  
O comando especifica a opção `--platform linux/amd64` para garantir que seu contêiner seja compatível com o ambiente de execução do Lambda, independentemente da arquitetura da sua máquina de compilação. Se você pretende criar uma função do Lambda usando a arquitetura do conjunto de instruções ARM64, certifique-se de alterar o comando para usar a opção `--platform linux/arm64` em vez disso.

### (Opcional) Teste a imagem localmente
<a name="go-custom-test"></a>

Use o [emulador de interface de runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/) para testar sua imagem localmente. A imagem base `provided.al2023` inclui o emulador de interface de runtime.

**Para executar o emulador de interface de runtime na sua máquina local**

1. Inicie a imagem do Docker com o comando **docker run**. Observe o seguinte:
   + `docker-image` é o nome da imagem e `test` é a tag.
   + `./main` é o `ENTRYPOINT` do seu Dockerfile.

   ```
   docker run -d -p 9000:8080 \
   --entrypoint /usr/local/bin/aws-lambda-rie \
   docker-image:test ./main
   ```

   Esse comando executa a imagem como um contêiner e cria um endpoint local em `localhost:9000/2015-03-31/functions/function/invocations`.

1. Em uma nova janela de terminal, publique um evento no seguinte endpoint usando um comando **curl**:

   ```
   curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
   ```

   Esse comando invoca a função com um evento vazio e retorna uma resposta. Algumas funções podem exigir uma carga útil JSON. Exemplo:

   ```
   curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
   ```

1. Obtenha o ID do contêiner.

   ```
   docker ps
   ```

1. Use o comando [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) para parar o contêiner. Nesse comando, substitua `3766c4ab331c` pelo ID do contêiner da etapa anterior.

   ```
   docker kill 3766c4ab331c
   ```

### Implantação da imagem
<a name="go-custom-deploy"></a>

**Para enviar a imagem ao Amazon ECR e criar a função do Lambda**

1. Execute o comando [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html) para autenticar a CLI do Docker no seu registro do Amazon ECR.
   + Defina o valor `--region` para a Região da AWS onde você deseja criar o repositório do Amazon ECR.
   + Substituir `111122223333` por seu ID da Conta da AWS.

   ```
   aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
   ```

1. Crie um repositório no Amazon ECR usando o comando [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).

   ```
   aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
   ```
**nota**  
O repositório do Amazon ECR deve estar na mesma Região da AWS que a função do Lambda.

   Se tiver êxito, você verá uma resposta como esta:

   ```
   {
       "repository": {
           "repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
           "registryId": "111122223333",
           "repositoryName": "hello-world",
           "repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
           "createdAt": "2023-03-09T10:39:01+00:00",
           "imageTagMutability": "MUTABLE",
           "imageScanningConfiguration": {
               "scanOnPush": true
           },
           "encryptionConfiguration": {
               "encryptionType": "AES256"
           }
       }
   }
   ```

1. Copie o `repositoryUri` da saída na etapa anterior.

1. Execute o comando [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) para aplicar uma tag na sua imagem local em seu repositório do Amazon ECR como a versão mais recente. Neste comando:
   + `docker-image:test` é o nome e a [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) da sua imagem do Docker. Esse é o nome e a tag da imagem que você especificou no comando `docker build`.
   + Substitua `<ECRrepositoryUri>` pelo `repositoryUri` que você copiou. Certifique-se de incluir `:latest` no final do URI.

   ```
   docker tag docker-image:test <ECRrepositoryUri>:latest
   ```

   Exemplo:

   ```
   docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
   ```

1. Execute o comando [docker push](https://docs.docker.com/engine/reference/commandline/push/) para implantar a imagem local no repositório do Amazon ECR. Certifique-se de incluir `:latest` no final do URI do repositório.

   ```
   docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
   ```

1. [Crie um perfil de execução](lambda-intro-execution-role.md#permissions-executionrole-api) para a função, caso ainda não tenha um. Você precisará do nome do recurso da Amazon (ARN) do perfil na próxima etapa.

1. Criar a função do Lambda. Em `ImageUri`, especifique o URI do repositório anterior. Certifique-se de incluir `:latest` no final do URI.

   ```
   aws lambda create-function \
     --function-name hello-world \
     --package-type Image \
     --code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
     --role arn:aws:iam::111122223333:role/lambda-ex
   ```
**nota**  
É possível criar uma função usando uma imagem em uma conta da AWS diferente desde que a imagem esteja na mesma região da função do Lambda. Para obter mais informações, consulte [Permissões entre contas do Amazon ECR](images-create.md#configuration-images-xaccount-permissions).

1. Invoque a função.

   ```
   aws lambda invoke --function-name hello-world response.json
   ```

   Você obterá uma resposta parecida com esta:

   ```
   {
     "ExecutedVersion": "$LATEST", 
     "StatusCode": 200
   }
   ```

1. Para ver a saída da função, verifique o arquivo `response.json`.

Para atualizar o código da função, você deve criar a imagem novamente, fazer upload da nova imagem no repositório do Amazon ECR e, em seguida, usar o comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) para implantar a imagem na função do Lambda.

O Lambda resolve a tag de imagem em um resumo de imagem específico. Isso significa que, se você apontar a tag de imagem que foi usada para implantar a função em uma nova imagem no Amazon ECR, o Lambda não atualizará automaticamente a função para usar a nova imagem.

Para implantar a nova imagem na mesma função do Lambda, você deverá usar o comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html), mesmo que a tag da imagem no Amazon ECR permaneça a mesma. No exemplo a seguir, a opção `--publish` cria uma nova versão da função usando a imagem de contêiner atualizada.

```
aws lambda update-function-code \
  --function-name hello-world \
  --image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
  --publish
```

## Usar uma imagem base que não é da AWS
<a name="go-image-other"></a>

Você pode criar uma imagem de contêiner para Go baseada em uma imagem base que não seja da AWS. O Dockerfile de exemplo das etapas a seguir usa uma [imagem base do Alpine](https://hub.docker.com/_/golang/).

Você deve incluir o pacote [aws-lambda-go/lambda](https://github.com/aws/aws-lambda-go) com seu manipulador de Go. Esse pacote implementa o modelo de programação para Go, incluindo a interface de runtime.

### Pré-requisitos
<a name="go-alt-prerequisites"></a>

Para executar as etapas desta seção, você deve ter o seguinte:
+ [AWS CLI versão 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versão mínima 25.0.0)
+ O plug-in [buildx](https://github.com/docker/buildx/blob/master/README.md) do Docker.
+ Go

### Criar uma imagem de uma imagem base alternativa
<a name="go-alt-create"></a>

**Para criar e implantar uma função do Go com uma imagem base do Alpine**

1. Crie um diretório para o projeto e depois mude para esse diretório.

   ```
   mkdir hello
   cd hello
   ```

1. Inicialize um novo módulo do Go.

   ```
   go mod init example.com/hello-world
   ```

1. Adicione a biblioteca **lambda** como uma dependência do seu novo módulo.

   ```
   go get github.com/aws/aws-lambda-go/lambda
   ```

1. Crie um arquivo denominado `main.go` e abra-o em um editor de texto. Este é o código da função  do Lambda. É possível usar o código de exemplo a seguir para fins de teste ou substituí-lo pelo seu próprio código.

   ```
   package main
   
   import (
   	"context"
   	"github.com/aws/aws-lambda-go/events"
   	"github.com/aws/aws-lambda-go/lambda"
   )
   
   func handler(ctx context.Context, event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
   	response := events.APIGatewayProxyResponse{
   		StatusCode: 200,
   		Body:       "\"Hello from Lambda!\"",
   	}
   	return response, nil
   }
   
   func main() {
   	lambda.Start(handler)
   }
   ```

1. Use um editor de texto para criar um Dockerfile no diretório do projeto. O Dockerfile de exemplo a seguir usa uma [imagem base do Alpine](https://hub.docker.com/_/golang/). Observe que o Dockerfile de exemplo não inclui uma [instrução USER](https://docs.docker.com/reference/dockerfile/#user). Quando você implanta uma imagem de contêiner no Lambda, o Lambda define automaticamente um usuário padrão do Linux com permissões de privilégio mínimo. Isso é diferente do comportamento padrão do Docker, que adota o usuário `root` como padrão quando nenhuma instrução `USER` é fornecida.  
**Example Dockerfile**  
**nota**  
Certifique-se de que a versão do Go que você especifica em seu Dockerfile (por exemplo, `golang:1.20`) seja a mesma versão do Go que você usou para criar sua aplicação.

   ```
   FROM golang:1.20.2-alpine3.16 as build
   WORKDIR /helloworld
   # Copy dependencies list
   COPY go.mod go.sum ./
   # Build
   COPY main.go .
   RUN go build -o main main.go
   # Copy artifacts to a clean image
   FROM alpine:3.16
   COPY --from=build /helloworld/main /main
   ENTRYPOINT [ "/main" ]
   ```

1. Crie a imagem do Docker com o comando [docker build](https://docs.docker.com/engine/reference/commandline/build/). O exemplo a seguir nomeia a imagem como `docker-image` e atribui a ela a [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) `test`. Para tornar sua imagem compatível com o Lambda, é necessário usar a opção `--provenance=false`.

   ```
   docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
   ```
**nota**  
O comando especifica a opção `--platform linux/amd64` para garantir que seu contêiner seja compatível com o ambiente de execução do Lambda, independentemente da arquitetura da sua máquina de compilação. Se você pretende criar uma função do Lambda usando a arquitetura do conjunto de instruções ARM64, certifique-se de alterar o comando para usar a opção `--platform linux/arm64` em vez disso.

### (Opcional) Teste a imagem localmente
<a name="go-alt-test"></a>

Use o [emulador de interface de runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/) para testar a imagem localmente. É possível [compilar o emulador em sua imagem](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#build-rie-into-your-base-image) ou usar o procedimento a seguir instalá-lo na sua máquina local.

**Para instalar o emulador de interface de runtime na sua máquina local**

1. No diretório do projeto, execute o comando a seguir para baixar o emulador de interface de runtime (arquitetura x86-64) do GitHub e instalá-lo na sua máquina local.

------
#### [ Linux/macOS ]

   ```
   mkdir -p ~/.aws-lambda-rie && \
       curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && \
       chmod +x ~/.aws-lambda-rie/aws-lambda-rie
   ```

   Para instalar o emulador arm64, substitua o URL do repositório do GitHub no comando anterior pelo seguinte:

   ```
   https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
   ```

------
#### [ PowerShell ]

   ```
   $dirPath = "$HOME\.aws-lambda-rie"
   if (-not (Test-Path $dirPath)) {
       New-Item -Path $dirPath -ItemType Directory
   }
         
   $downloadLink = "https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie"
   $destinationPath = "$HOME\.aws-lambda-rie\aws-lambda-rie"
   Invoke-WebRequest -Uri $downloadLink -OutFile $destinationPath
   ```

   Para instalar o emulador de arm64, substitua `$downloadLink` pelo seguinte:

   ```
   https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
   ```

------

1. Inicie a imagem do Docker com o comando **docker run**. Observe o seguinte:
   + `docker-image` é o nome da imagem e `test` é a tag.
   + `/main` é o `ENTRYPOINT` do seu Dockerfile.

------
#### [ Linux/macOS ]

   ```
   docker run --platform linux/amd64 -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
       --entrypoint /aws-lambda/aws-lambda-rie \
       docker-image:test \
           /main
   ```

------
#### [ PowerShell ]

   ```
   docker run --platform linux/amd64 -d -v "$HOME\.aws-lambda-rie:/aws-lambda" -p 9000:8080 `
   --entrypoint /aws-lambda/aws-lambda-rie `
   docker-image:test `
       /main
   ```

------

   Esse comando executa a imagem como um contêiner e cria um endpoint local em `localhost:9000/2015-03-31/functions/function/invocations`.
**nota**  
Se você criou a imagem do Docker para a arquitetura do conjunto de instruções ARM64, certifique-se de usar a opção `--platform linux/arm64`, em vez de `--platform linux/amd64`.

1. Publique um evento no endpoint local.

------
#### [ Linux/macOS ]

   No Linux e no MacOS, execute o seguinte comando `curl`:

   ```
   curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
   ```

   Esse comando invoca a função com um evento vazio e retorna uma resposta. Caso esteja usando seu próprio código de função em vez do código de função de exemplo, você talvez queira invocar a função com uma carga útil JSON. Exemplo:

   ```
   curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
   ```

------
#### [ PowerShell ]

   No PowerShell, execute o seguinte comando `Invoke-WebRequest`:

   ```
   Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
   ```

   Esse comando invoca a função com um evento vazio e retorna uma resposta. Caso esteja usando seu próprio código de função em vez do código de função de exemplo, você talvez queira invocar a função com uma carga útil JSON. Exemplo:

   ```
   Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
   ```

------

1. Obtenha o ID do contêiner.

   ```
   docker ps
   ```

1. Use o comando [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) para parar o contêiner. Nesse comando, substitua `3766c4ab331c` pelo ID do contêiner da etapa anterior.

   ```
   docker kill 3766c4ab331c
   ```

### Implantação da imagem
<a name="go-alt-deploy"></a>

**Para enviar a imagem ao Amazon ECR e criar a função do Lambda**

1. Execute o comando [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html) para autenticar a CLI do Docker no seu registro do Amazon ECR.
   + Defina o valor `--region` para a Região da AWS onde você deseja criar o repositório do Amazon ECR.
   + Substituir `111122223333` por seu ID da Conta da AWS.

   ```
   aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
   ```

1. Crie um repositório no Amazon ECR usando o comando [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).

   ```
   aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
   ```
**nota**  
O repositório do Amazon ECR deve estar na mesma Região da AWS que a função do Lambda.

   Se tiver êxito, você verá uma resposta como esta:

   ```
   {
       "repository": {
           "repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
           "registryId": "111122223333",
           "repositoryName": "hello-world",
           "repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
           "createdAt": "2023-03-09T10:39:01+00:00",
           "imageTagMutability": "MUTABLE",
           "imageScanningConfiguration": {
               "scanOnPush": true
           },
           "encryptionConfiguration": {
               "encryptionType": "AES256"
           }
       }
   }
   ```

1. Copie o `repositoryUri` da saída na etapa anterior.

1. Execute o comando [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) para aplicar uma tag na sua imagem local em seu repositório do Amazon ECR como a versão mais recente. Neste comando:
   + `docker-image:test` é o nome e a [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) da sua imagem do Docker. Esse é o nome e a tag da imagem que você especificou no comando `docker build`.
   + Substitua `<ECRrepositoryUri>` pelo `repositoryUri` que você copiou. Certifique-se de incluir `:latest` no final do URI.

   ```
   docker tag docker-image:test <ECRrepositoryUri>:latest
   ```

   Exemplo:

   ```
   docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
   ```

1. Execute o comando [docker push](https://docs.docker.com/engine/reference/commandline/push/) para implantar a imagem local no repositório do Amazon ECR. Certifique-se de incluir `:latest` no final do URI do repositório.

   ```
   docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
   ```

1. [Crie um perfil de execução](lambda-intro-execution-role.md#permissions-executionrole-api) para a função, caso ainda não tenha um. Você precisará do nome do recurso da Amazon (ARN) do perfil na próxima etapa.

1. Criar a função do Lambda. Em `ImageUri`, especifique o URI do repositório anterior. Certifique-se de incluir `:latest` no final do URI.

   ```
   aws lambda create-function \
     --function-name hello-world \
     --package-type Image \
     --code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
     --role arn:aws:iam::111122223333:role/lambda-ex
   ```
**nota**  
É possível criar uma função usando uma imagem em uma conta da AWS diferente desde que a imagem esteja na mesma região da função do Lambda. Para obter mais informações, consulte [Permissões entre contas do Amazon ECR](images-create.md#configuration-images-xaccount-permissions).

1. Invoque a função.

   ```
   aws lambda invoke --function-name hello-world response.json
   ```

   Você obterá uma resposta parecida com esta:

   ```
   {
     "ExecutedVersion": "$LATEST", 
     "StatusCode": 200
   }
   ```

1. Para ver a saída da função, verifique o arquivo `response.json`.

Para atualizar o código da função, você deve criar a imagem novamente, fazer upload da nova imagem no repositório do Amazon ECR e, em seguida, usar o comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) para implantar a imagem na função do Lambda.

O Lambda resolve a tag de imagem em um resumo de imagem específico. Isso significa que, se você apontar a tag de imagem que foi usada para implantar a função em uma nova imagem no Amazon ECR, o Lambda não atualizará automaticamente a função para usar a nova imagem.

Para implantar a nova imagem na mesma função do Lambda, você deverá usar o comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html), mesmo que a tag da imagem no Amazon ECR permaneça a mesma. No exemplo a seguir, a opção `--publish` cria uma nova versão da função usando a imagem de contêiner atualizada.

```
aws lambda update-function-code \
  --function-name hello-world \
  --image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
  --publish
```

# Como trabalhar com camadas para funções do Lambda em Go
<a name="golang-layers"></a>

Não recomendamos usar [camadas](chapter-layers.md) para gerenciar dependências de funções do Lambda escritas em Go. Isso ocorre porque as funções do Lambda em Go são compiladas em um único executável que você fornece ao Lambda ao implantar sua função. Esse executável contém seu código de função compilado, junto com todas as suas dependências. O uso de camadas não apenas complica esse processo, mas também aumenta os tempos de inicialização a frio, pois suas funções precisam carregar manualmente assemblies extras na memória durante a fase inicial.

Para usar dependências externas com seus manipuladores de Go, inclua-as diretamente em seu pacote de implantação. Ao fazer isso, você simplifica o processo de implantação e também aproveita as otimizações integradas do compilador Go. Para ver um exemplo de como importar e usar uma dependência como o AWS SDK para Go em sua função, consulte. [Definição dos manipuladores de função do Lambda em Go](golang-handler.md)

# Registrar em log e monitorar funções do Lambda em Go
<a name="golang-logging"></a>

O AWS Lambda monitora automaticamente as funções do Lambda em seu nome e envia logs para o Amazon CloudWatch. Sua função do Lambda vem com um grupo de logs do CloudWatch Logs e uma transmissão de logs para cada instância de sua função. O ambiente do runtime do Lambda envia detalhes sobre cada invocação à transmissão de logs e transmite os logs e outras saídas do código de sua função. Para obter mais informações, consulte [Enviar logs de função do Lambda para o CloudWatch Logs](monitoring-cloudwatchlogs.md).

Esta página descreve como produzir saída em log usando o código de função do Lambda e como acessar os logs usando a AWS Command Line Interface, o console do Lambda ou o console do CloudWatch.

**Topics**
+ [

## Criar uma função que retorna logs
](#golang-logging-output)
+ [

## Visualizar logs no console do Lambda
](#golang-logging-console)
+ [

## Visualização de logs no console do CloudWatch
](#golang-logging-cwconsole)
+ [

## Visualizar logs usando a AWS Command Line Interface (AWS CLI)
](#golang-logging-cli)
+ [

## Excluir logs
](#golang-logging-delete)

## Criar uma função que retorna logs
<a name="golang-logging-output"></a>

Para gerar os logs do código de função, você pode usar métodos no [pacote fmt](https://golang.org/pkg/fmt/) ou qualquer biblioteca de logs que grave em `stdout` ou em `stderr`. O exemplo a seguir usa [o pacote de logs](https://golang.org/pkg/log/).

**Example [main.go](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-go/function/main.go): registro em log**  

```
func handleRequest(ctx context.Context, event events.SQSEvent) (string, error) {
  // event
  eventJson, _ := json.MarshalIndent(event, "", "  ")
  log.Printf("EVENT: %s", eventJson)
  // environment variables
  log.Printf("REGION: %s", os.Getenv("AWS_REGION"))
  log.Println("ALL ENV VARS:")
  for _, element := range os.Environ() {
    log.Println(element)
  }
```

**Example formato do log**  

```
START RequestId: dbda340c-xmpl-4031-8810-11bb609b4c71 Version: $LATEST
2020/03/27 03:40:05 EVENT: {
  "Records": [
    {
      "messageId": "19dd0b57-b21e-4ac1-bd88-01bbb068cb78",
      "receiptHandle": "MessageReceiptHandle",
      "body": "Hello from SQS!",
      "md5OfBody": "7b27xmplb47ff90a553787216d55d91d",
      "md5OfMessageAttributes": "",
      "attributes": {
        "ApproximateFirstReceiveTimestamp": "1523232000001",
        "ApproximateReceiveCount": "1",
        "SenderId": "123456789012",
        "SentTimestamp": "1523232000000"
      },
      ...
2020/03/27 03:40:05 AWS_LAMBDA_LOG_STREAM_NAME=2020/03/27/[$LATEST]569cxmplc3c34c7489e6a97ad08b4419
2020/03/27 03:40:05 AWS_LAMBDA_FUNCTION_NAME=blank-go-function-9DV3XMPL6XBC
2020/03/27 03:40:05 AWS_LAMBDA_FUNCTION_MEMORY_SIZE=128
2020/03/27 03:40:05 AWS_LAMBDA_FUNCTION_VERSION=$LATEST
2020/03/27 03:40:05 AWS_EXECUTION_ENV=AWS_Lambda_go1.x
END RequestId: dbda340c-xmpl-4031-8810-11bb609b4c71
REPORT RequestId: dbda340c-xmpl-4031-8810-11bb609b4c71	Duration: 38.66 ms	Billed Duration: 243 ms	Memory Size: 128 MB	Max Memory Used: 54 MB	Init Duration: 203.69 ms	
XRAY TraceId: 1-5e7d7595-212fxmpl9ee07c4884191322	SegmentId: 42ffxmpl0645f474	Sampled: true
```

O runtime do Go registra em log as linhas `START`, `END` e `REPORT` para cada invocação. A linha do relatório fornece os detalhes a seguir.

**RELATAR campos de dados de linha**
+ **RequestId**: o ID de solicitação exclusivo para a invocação.
+ **Duração**: a quantidade de tempo que o método de manipulador da função gastou processando o evento.
+ **Duração faturada**: a quantia de tempo faturada para a invocação.
+ **Tamanho da memória**: a quantidade de memória alocada para a função.
+ **Memória máxima utilizada**: a quantidade de memória utilizada pela função. Quando as invocações compartilham um ambiente de execução, o Lambda relata a memória máxima usada em todas as invocações. Esse comportamento pode resultar em um valor relatado maior do que o esperado.
+ **Duração inicial**: para a primeira solicitação atendida, a quantidade de tempo que o runtime levou para carregar a função e executar o código fora do método do handler.
+ **XRAY TraceId**: para solicitações rastreadas, o [ID de rastreamento do AWS X-Ray](services-xray.md).
+ **SegmentId**: para solicitações rastreadas, o ID do segmento do X-Ray.
+ **Amostragem**: para solicitações rastreadas, o resultado da amostragem.

## Visualizar logs no console do Lambda
<a name="golang-logging-console"></a>

É possível usar o console do Lambda para exibir a saída do log depois de invocar uma função do Lambda.

Se seu código puder ser testado no editor de **Código** incorporado, você encontrará logs nos **resultados de execução**. Ao usar o recurso de teste do console para invocar uma função, você encontrará **Saída de log** na seção **Detalhes**.

## Visualização de logs no console do CloudWatch
<a name="golang-logging-cwconsole"></a>

É possível usar o console do Amazon CloudWatch para exibir logs de todas as invocações da função do Lambda.

**Para visualizar logs no console do CloudWatch**

1. No console do Amazon CloudWatch, abra a [página Log groups](https://console.aws.amazon.com/cloudwatch/home?#logs:) (Grupos de log).

1. Escolha o grupo de logs de sua função (**/aws/lambda/*nome-de-sua-função***).

1. Escolha um stream de logs.

Cada fluxo de log corresponde a uma [instância da sua função](lambda-runtime-environment.md). Um fluxo de logs é exibido quando você atualiza sua função do Lambda e quando mais instâncias são criadas para lidar com invocações simultâneas. Para localizar logs de uma invocação específica, recomendamos intrumentar sua função com AWS X-Ray. O X-Ray registra detalhes sobre a solicitação e o stream de logs no rastreamento.

## Visualizar logs usando a AWS Command Line Interface (AWS CLI)
<a name="golang-logging-cli"></a>

O AWS CLI é uma ferramenta de código aberto que permite interagir com os serviços do AWS usando comandos no shell da linha de comando. Para concluir as etapas desta seção, você deve ter a [versão 2 da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

É possível usar a [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) para recuperar logs de uma invocação usando a opção de comando `--log-type`. A resposta contém um campo `LogResult` com até 4 KB de logs codificados em base64 obtidos da invocação.

**Example recuperar um ID de log**  
O exemplo a seguir mostra como recuperar um *ID de log* do campo `LogResult` para uma função chamada `my-function`.  

```
aws lambda invoke --function-name my-function out --log-type Tail
```
A seguinte saída deverá ser mostrada:  

```
{
    "StatusCode": 200,
    "LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
    "ExecutedVersion": "$LATEST"
}
```

**Example decodificar os logs**  
No mesmo prompt de comando, use o utilitário `base64` para decodificar os logs. O exemplo a seguir mostra como recuperar logs codificados em base64 de `my-function`.  

```
aws lambda invoke --function-name my-function out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode
```
A opção **cli-binary-format** será necessária se você estiver usando a AWS CLI versão 2. Para que essa seja a configuração padrão, execute `aws configure set cli-binary-format raw-in-base64-out`. Para obter mais informações, consulte [A AWS CLI comporta opções de linha de comando globais](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) no *Guia do usuário da AWS Command Line Interface versão 2*.  
A seguinte saída deverá ser mostrada:  

```
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8  Duration: 79.67 ms      Billed Duration: 80 ms         Memory Size: 128 MB     Max Memory Used: 73 MB
```
O utilitário `base64` está disponível no Linux, macOS e [Ubuntu no Windows](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Os usuários do macOS precisam usar `base64 -D`.

**Example get-logs.sh script**  
No mesmo prompt de comando, use o script a seguir para fazer download dos últimos cinco eventos de log. O script usa `sed` para remover as aspas do arquivo de saída e fica inativo por 15 segundos para que os logs tenham tempo de ficar disponíveis. A saída inclui a resposta do Lambda, e a saída do comando `get-log-events`.   
Copie o conteúdo do exemplo de código a seguir e salve no diretório de seu projeto do Lambda como `get-logs.sh`.  
A opção **cli-binary-format** será necessária se você estiver usando a AWS CLI versão 2. Para que essa seja a configuração padrão, execute `aws configure set cli-binary-format raw-in-base64-out`. Para obter mais informações, consulte [A AWS CLI comporta opções de linha de comando globais](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) no *Guia do usuário da AWS Command Line Interface versão 2*.  

```
#!/bin/bash
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name stream1 --limit 5
```

**Example macOS e Linux (somente)**  
No mesmo prompt de comando, os usuários do macOS e do Linux podem precisar executar o comando a seguir para garantir que o script seja executável.  

```
chmod -R 755 get-logs.sh
```

**Example recuperar os últimos cinco eventos de log**  
No mesmo prompt de comando, execute o script a seguir para obter os últimos cinco eventos de log.  

```
./get-logs.sh
```
A seguinte saída deverá ser mostrada:  

```
{
    "StatusCode": 200,
    "ExecutedVersion": "$LATEST"
}
{
    "events": [
        {
            "timestamp": 1559763003171,
            "message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",
            "ingestionTime": 1559763003309
        },
        {
            "timestamp": 1559763003173,
            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r  \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003173,
            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r  \"key\": \"value\"\r}\n",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003218,
            "message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003218,
            "message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
            "ingestionTime": 1559763018353
        }
    ],
    "nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
    "nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}
```

## Excluir logs
<a name="golang-logging-delete"></a>

Os grupos de logs não são excluídos automaticamente excluídos quando você exclui uma função. Para evitar armazenar logs indefinidamente, exclua o grupo de logs ou[Configurar um período de retenção](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention)após o qual os logs são excluídos automaticamente.

# Instrumentação do código Go no AWS Lambda
<a name="golang-tracing"></a>

O Lambda se integra ao AWS X-Ray para ajudar você a rastrear, depurar e otimizar aplicações do Lambda. É possível usar o X-Ray para rastrear uma solicitação enquanto ela atravessa recursos na aplicação, o que pode incluir funções Lambda e outros produtos da AWS.

Para enviar dados de rastreamento ao X-Ray, você pode usar uma das duas bibliotecas SDK:
+ [AWS Distro for OpenTelemetry (ADOT)](https://aws.amazon.com/otel): uma distribuição segura, pronta para produção e com suporte na AWS do SDK OpenTelemetry (OTel).
+ [AWS X-Ray SDK para Go](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-go.html): um SDK para geração e envio de dados de rastreamento ao X-Ray.

Cada um dos SDKs oferece maneiras de enviar dados de telemetria ao serviço do X-Ray. Em seguida, é possível usar o X-Ray para visualizar, filtrar e obter insights sobre as métricas de performance da aplicação para identificar problemas e oportunidades de otimização.

**Importante**  
Os SDKs do X-Ray e do Powertools para AWS Lambda fazem parte de uma solução de instrumentação totalmente integrada oferecida pela AWS. As camadas do Lambda para ADOT fazem parte de um padrão em todo o setor para instrumentação de rastreamento que coleta mais dados em geral, mas pode não ser adequado para todos os casos de uso. É possível implementar o rastreamento de ponta a ponta no X-Ray usando ambas as soluções. Para saber mais sobre como escolher entre elas, consulte [Como escolher entre os SDKs do AWS Distro para OpenTelemetry e do X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/xray-instrumenting-your-app.html#xray-instrumenting-choosing).

**Topics**
+ [

## Usar o ADOT para instrumentar funções Go
](#golang-adot)
+ [

## Usar o SDK do X-Ray para instrumentar suas funções Go
](#golang-xray-sdk)
+ [

## Ativar o rastreamento com o console do Lambda
](#golang-tracing-console)
+ [

## Ativar o rastreamento com a API do Lambda
](#golang-tracing-api)
+ [

## Ativar o rastreamento com o CloudFormation
](#golang-tracing-cloudformation)
+ [

## Interpretar um rastreamento do X-Ray
](#golang-tracing-interpretation)

## Usar o ADOT para instrumentar funções Go
<a name="golang-adot"></a>

O ADOT fornece [camadas](chapter-layers.md) do Lambda totalmente gerenciadas que empacotam tudo o que você precisa para coletar dados de telemetria usando o SDK do OTel. Ao consumir essa camada, é possível instrumentar suas funções Lambda sem precisar modificar nenhum código de função. Você também pode configurar sua camada para fazer a inicialização personalizada do OTel. Para obter mais informações, consulte [Custom configuration for the ADOT Collector on Lambda](https://aws-otel.github.io/docs/getting-started/lambda#custom-configuration-for-the-adot-collector-on-lambda) (Configuração personalizada para o ADOT Collector no Lambda) na documentação do ADOT.

Para runtimes Go, você pode adicionar a **camada do Lambda gerenciada pela AWS para ADOT Go** a fim de instrumentar suas funções automaticamente. Para obter instruções detalhadas sobre como adicionar essa camada, consulte [Suporte do AWS Distro for OpenTelemetry Lambda para Go](https://aws-otel.github.io/docs/getting-started/lambda/lambda-go), na documentação do ADOT.

## Usar o SDK do X-Ray para instrumentar suas funções Go
<a name="golang-xray-sdk"></a>

Para registrar detalhes sobre as chamadas feitas pela sua função do Lambda para outros recursos na sua aplicação, você também pode usar o AWS X-Ray SDK para Go. Para obter o SDK, baixe-o do [Repositório do GitHub](https://github.com/aws/aws-xray-sdk-go) com `go get`:

```
go get github.com/aws/aws-xray-sdk-go
```

Para instrumentar clientes do AWS SDK, passe o cliente para o método `xray.AWS()`. Em seguida, você pode rastrear chamadas usando a versão `WithContext` do método.

```
svc := s3.New(session.New())
xray.AWS(svc.Client)
...
svc.ListBucketsWithContext(ctx aws.Context, input *ListBucketsInput)
```

Depois de adicionar as dependências corretas e fazer as devidas mudanças de código, ative o rastreamento na configuração da sua função usando o console do Lambda ou a API.

## Ativar o rastreamento com o console do Lambda
<a name="golang-tracing-console"></a>

Para alternar o rastreamento ativo na sua função do Lambda usando o console, siga as etapas abaixo:

**Para ativar o rastreamento ativo**

1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda.

1. Escolha uma função.

1. Escolha **Configuration** (Configuração) e depois **Monitoring and operations tools** (Ferramentas de monitoramento e operações).

1. Em **Ferramentas de monitoramento adicionais**, selecione **Editar**.

1. Em **CloudWatch Application Signals e AWS X-Ray**, escolha **Habilitar** para **Rastreamentos do serviço Lambda**.

1. Escolha **Salvar**.

## Ativar o rastreamento com a API do Lambda
<a name="golang-tracing-api"></a>

Configure o rastreamento na sua função do Lambda com a AWS CLI ou o AWS SDK, usando as seguintes operações de API:
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
+ [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html)
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)

O exemplo de comando da AWS CLI a seguir habilita o rastreamento ativo em uma função chamada **my-function**.

```
aws lambda update-function-configuration --function-name my-function \
--tracing-config Mode=Active
```

O modo de rastreamento faz parte da configuração específica da versão quando você publica uma versão da função. Não é possível alterar o modo de rastreamento em uma versão publicada.

## Ativar o rastreamento com o CloudFormation
<a name="golang-tracing-cloudformation"></a>

Para ativar o rastreamento ativo em um recurso `AWS::Lambda::Function` em um modelo do CloudFormation, use a propriedade `TracingConfig`.

**Example [function-inline.yml](https://github.com/awsdocs/aws-lambda-developer-guide/blob/master/templates/function-inline.yml): configuração de rastreamento**  

```
Resources:
  function:
    Type: [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
    Properties:
      TracingConfig:
        Mode: Active
      ...
```

Para um recurso do AWS Serverless Application Model (AWS SAM) `AWS::Serverless::Function`, use a propriedade `Tracing`.

**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/template.yml): configuração de rastreamento**  

```
Resources:
  function:
    Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
    Properties:
      Tracing: Active
      ...
```

## Interpretar um rastreamento do X-Ray
<a name="golang-tracing-interpretation"></a>

Sua função precisa de permissão para carregar dados de rastreamento no X-Ray. Quando você ativa o rastreamento ativo no console do Lambda, o Lambda adiciona as permissões necessárias à [função de execução](lambda-intro-execution-role.md) da função. Caso contrário, adicione a política [AWSXRayDaemonWriteAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess) à função de execução.

Após configurar o rastreamento ativo, você pode observar solicitações específicas por meio da aplicação. O [grafo de serviço do X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html#xray-concepts-servicegraph) exibe informações sobre sua aplicação e todos os componentes. O exemplo a seguir mostra uma aplicação com duas funções. A função principal processa eventos e, às vezes, retorna erros. A segunda função de cima para baixo processa erros que aparecem no primeiro grupo de logs e usa o AWS SDK para chamar o X-Ray, o Amazon Simple Storage Service (Amazon S3) e o Amazon CloudWatch Logs.

![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/sample-errorprocessor-servicemap.png)


O X-Ray não rastreia todas as solicitações para sua aplicação. O X-Ray aplica um algoritmo de amostragem para garantir que o rastreamento seja eficiente, enquanto ainda fornece uma amostra representativa das solicitações. A taxa de amostragem é uma solicitação por segundo e 5% de solicitações adicionais. Você não pode configurar a taxa de amostragem do X-Ray para suas funções.

No X-Ray, um *rastreamento* registra informações sobre uma solicitação que é processada por um ou mais *serviços*. O Lambda registra dois segmentos por rastreamento, o que cria dois nós no gráfico de serviços. A imagem a seguir destaca esses dois nós:

![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/xray-servicemap-function.png)


O primeiro nó à esquerda representa o serviço do Lambda, que recebe a solicitação de invocação. O segundo nó representa a sua função do Lambda específica. O exemplo a seguir mostra um rastreamento com esses dois segmentos. Ambos têm o nome **my-function**, mas um tem a origem `AWS::Lambda` e o outro, a origem `AWS::Lambda::Function`. Se o segmento `AWS::Lambda` mostrar um erro, o serviço Lambda teve um problema. Se o segmento `AWS::Lambda::Function` mostrar um erro, sua função teve um problema.

![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)


Este exemplo expande o segmento `AWS::Lambda::Function` para mostrar seus três subsegmentos.

**nota**  
A AWS atualmente está implementando alterações no serviço Lambda. Devido a essas alterações, você pode ver pequenas diferenças entre a estrutura e o conteúdo das mensagens de log do sistema e os segmentos de rastreamento emitidos por diferentes funções do Lambda na sua Conta da AWS.  
O exemplo de rastreamento mostrado aqui ilustra o segmento de função no estilo antigo. As diferenças entre os segmentos no estilo antigo e no estilo novo são descritas nos próximos parágrafos.  
Essas alterações serão implementadas durante as próximas semanas, e todas as funções em todas as Regiões da AWS, exceto nas regiões China e GovCloud, passarão a usar o novo formato de mensagens de log e segmentos de rastreamento.

O segmento de função no estilo antigo contém os seguintes subsegmentos:
+ **Inicialização**: representa o tempo gasto carregando a função e executando o [código de inicialização](foundation-progmodel.md). Esse subsegmento aparece somente para o primeiro evento que cada instância da função processa.
+ **Invocação**: representa o tempo gasto na execução do código do manipulador.
+ **Sobrecarga**: representa o tempo gasto pelo runtime do Lambda preparando-se para lidar com o próximo evento.

O segmento de função no estilo novo não contém um subsegmento `Invocation`. Em vez disso, os subsegmentos dos clientes são anexados diretamente ao segmento da função. Para obter mais informações sobre a estrutura dos segmentos de função no estilo antigo e no estilo novo, consulte [Noções básicas sobre rastreamentos do X-Ray](services-xray.md#services-xray-traces).

Você também pode instrumentar clientes HTTP, registrar consultas SQL e criar subsegmentos personalizados com anotações e metadados. Para obter mais informações, consulte [AWS X-Ray SDK para Go](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html), no *Guia do desenvolvedor do AWS X-Ray*.

**Preços**  
Você pode usar o rastreamento do X-Ray gratuitamente todos os meses até determinado limite como parte do nível gratuito da AWS. Além do limite, o X-Ray cobra por armazenamento e recuperação de rastreamento. Para obter mais informações, consulte [Definição de preçoAWS X-Ray](https://aws.amazon.com/xray/pricing/).