# Creación de funciones de Lambda con Go
Go se implementa de manera distinta a otros tiempos de ejecución administrados. Como Go se compila de forma nativa en un archivo binario ejecutable, no requiere un tiempo de ejecución de lenguaje dedicado. Utilice un [tiempo de ejecución exclusivo para el sistema operativo](runtimes-provided.md) (la familia de tiempos de ejecución `provided`) para implementar las funciones de Go en Lambda.
**Topics**
+ [Compatibilidad del tiempo de ejecución de Go](#golang-al1)
+ [Herramientas y bibliotecas](#golang-libraries)
+ [Definición de controladores de funciones de Lambda en Go](golang-handler.md)
+ [Uso del objeto de contexto Lambda para recuperar la información de la función Go](golang-context.md)
+ [Implementar funciones de Lambda en Go con archivos .zip](golang-package.md)
+ [Implemente funciones Go Lambda con imágenes de contenedor](go-image.md)
+ [Uso de capas para funciones de Lambda en Go](golang-layers.md)
+ [Registro y supervisión de las funciones de Lambda en Go](golang-logging.md)
+ [Instrumentación del código Go en AWS Lambda](golang-tracing.md)
## Compatibilidad del tiempo de ejecución de Go
El tiempo de ejecución administrado de Go 1.x para Lambda ha quedado [obsoleto](lambda-runtimes.md#runtime-support-policy). Si tiene funciones que usan el tiempo de ejecución de Go 1.x, debe migrar sus funciones a `provided.al2023` o `provided.al2`. Los tiempos de ejecución `provided.al2023` y `provided.al2` ofrecen varias ventajas sobre `go1.x`, incluida la compatibilidad con la arquitectura arm64 (procesadores Graviton2 de AWS), binarios más pequeños y tiempos de invocación ligeramente más rápidos.
No se requieren cambios de código para esta migración. Los únicos cambios necesarios se refieren a la forma en que se compila el paquete de implementación y al tiempo de ejecución que se utiliza para crear la función. Para obtener más información, consulte [Migración de las funciones de AWS Lambda del tiempo de ejecución de Go1.x al tiempo de ejecución personalizado en 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/) en el *Blog de computación de AWS*.
| Nombre | Identificador | Sistema operativo | Fecha de baja | Bloqueo de la función Crear | Bloqueo de la función Actualizar |
| --- | --- | --- | --- | --- | --- |
| Tiempo de ejecución exclusivo del sistema operativo | `provided.al2023` | Amazon Linux 2023 | 30 de junio de 2029 | 31 de julio de 2029 | 31 de agosto de 2029 |
| Tiempo de ejecución exclusivo del sistema operativo | `provided.al2` | Amazon Linux 2 | 31 de julio de 2026 | 31 de agosto de 2026 | 30 de septiembre de 2026 |
## Herramientas y bibliotecas
Lambda proporciona las siguientes herramientas y bibliotecas para el tiempo de ejecución Go:
+ [AWS SDK para Go v2](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2): el SDK oficial de AWS para el lenguaje de programación Go.
+ [github.com/aws/aws-lambda-go/lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda): la implementación del modelo de programación de Lambda para Go. AWS Lambda utiliza este paquete para invocar su [controlador](golang-handler.md).
+ [github.com/aws/aws-lambda-go/lambdacontext](https://github.com/aws/aws-lambda-go/tree/master/lambdacontext): elementos auxiliares para obtener acceso a la información de contexto del [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 proporciona definiciones de tipos para las integraciones de orígenes de eventos comunes.
+ [github.com/aws/aws-lambda-go/cmd/build-lambda-zip](https://github.com/aws/aws-lambda-go/tree/master/cmd/build-lambda-zip): Esta herramienta se puede utilizar para crear un archivo.zip en Windows.
Para obtener más información, consulte [aws-lambda-go](https://github.com/aws/aws-lambda-go) en GitHub.
Lambda proporciona las siguientes aplicaciones de ejemplo para el tiempo de ejecución Go:
**Aplicaciones de ejemplo de Lambda en Go**
+ [go-al2](https://github.com/aws-samples/sessions-with-aws-sam/tree/master/go-al2): una función de “Hola, mundo” que devuelve la dirección IP pública. Esta aplicación utiliza el tiempo de ejecución personalizado `provided.al2`.
+ [blank-go](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-go): una función Go que muestra el uso de las bibliotecas de Go de Lambda, el registro, las variables de entorno y el AWS SDK. Esta aplicación utiliza el tiempo de ejecución `go1.x`.
# Definición de controladores de funciones de Lambda en Go
El *controlador* de la función de Lambda es el método del código de la función que procesa eventos. Cuando se invoca una función, Lambda ejecuta el método del controlador. La función se ejecuta hasta que el controlador devuelve una respuesta, se cierra o se agota el tiempo de espera.
En esta página, se describe cómo trabajar con los controladores de funciones de Lambda en Go, incluida la configuración del proyecto, las convenciones de nomenclatura y las prácticas recomendadas. En esta página también se incluye el ejemplo de una función de Lambda de Go que recibe información sobre un pedido, genera un recibo en un archivo de texto y coloca este archivo en un bucket de Amazon Simple Storage Service (Amazon S3). Para obtener información sobre cómo implementar la función después de escribirla, consulte [Implementar funciones de Lambda en Go con archivos .zip](golang-package.md) o [Implemente funciones Go Lambda con imágenes de contenedor](go-image.md).
**Topics**
+ [Configuración del proyecto de controlador de Go](#golang-handler-setup)
+ [Código de función de Lambda de Go de ejemplo](#golang-example-code)
+ [Convenciones de nomenclatura de controladores](#golang-handler-naming)
+ [Definición del objeto de evento de entrada y acceso a él](#golang-example-input)
+ [Acceso y uso del objeto de contexto de Lambda](#golang-example-context)
+ [Firmas de controlador válidas para los controladores de Go](#golang-handler-signatures)
+ [Uso de la versión 2 de AWS SDK para Go en el controlador](#golang-example-sdk-usage)
+ [Acceso a las variables de entorno](#golang-example-envvars)
+ [Uso del estado global](#golang-handler-state)
+ [Prácticas recomendadas de codificación para las funciones de Lambda en Go](#go-best-practices)
## Configuración del proyecto de controlador de Go
Una función de Lambda escrita en [Go](https://golang.org/) se crea como ejecutable de Go. Puede inicializar un proyecto de función de Lambda de Go de la misma manera que inicializa cualquier otro proyecto de Go mediante el siguiente comando `go mod init`:
```
go mod init example-go
```
En este caso, `example-go` es el nombre del módulo. Puede sustituirlo por cualquier valor. Este comando inicializa el proyecto y genera el archivo `go.mod` que enumera las dependencias del proyecto.
Use el comando `go get` para agregar cualquier dependencia externa al proyecto. Por ejemplo, en todas las funciones de Lambda de Go, debe incluir el paquete [github.com/aws/aws-lambda-go/lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda), que implementa el modelo de programación de Lambda para Go. Incluye este paquete con el siguiente comando `go get`:
```
go get github.com/aws/aws-lambda-go
```
El código de la función debe estar en un archivo de Go. En el siguiente ejemplo, el nombre de este archivo es `main.go`. En este archivo, implementa la lógica de la función básica en un método de controlador, así como una función `main()` que llama a este controlador.
## Código de función de Lambda de Go de ejemplo
El siguiente ejemplo de código de función de Lambda de Go recibe información sobre un pedido, genera un recibo en un archivo de texto y coloca este archivo en un bucket de Amazon S3.
**Example Función de Lambda `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 archivo `main.go` contiene las siguientes secciones de código:
+ `package main`: en Go, el paquete que contiene la función `func main()` debe tener siempre el nombre `main`.
+ Bloque `import`: utilice este bloque para incluir las bibliotecas que requiere la función de Lambda.
+ Bloque `type Order struct {}`: defina la forma del evento de entrada esperado en esta estructura de Go.
+ Bloque `var ()`: utilice este bloque para definir cualquier variable global que vaya a utilizar en la función de Lambda.
+ `func init() {}`: incluya cualquier código que desee que Lambda ejecute durante la [fase de inicialización](lambda-runtime-environment.md#runtimes-lifecycle-ib) de este método `init()`.
+ `func uploadReceiptToS3(...) {}`: este es un método auxiliar al que hace referencia el método del controlador principal `handleRequest`.
+ `func handleRequest(ctx context.Context, event json.RawMessage) error {}`: este es el **método del controlador principal**, que contiene la lógica principal de la aplicación.
+ `func main() {}`: este es un punto de entrada obligatorio para el controlador de Lambda. El argumento del método `lambda.Start()` es el método del controlador principal.
Para que esta función funcione correctamente, su [rol de ejecución](lambda-intro-execution-role.md) debe permitir la acción `s3:PutObject`. Además, asegúrese de definir la variable de entorno `RECEIPT_BUCKET`. Tras una invocación correcta, el bucket de Amazon S3 debe contener un archivo de recibo.
## Convenciones de nomenclatura de controladores
En el caso de las funciones de Lambda de Go, es posible utilizar cualquier nombre para el controlador. En este ejemplo, el nombre del método del controlador es `handleRequest`. Para hacer referencia al valor del controlador en su código, puede utilizar la variable de entorno `_HANDLER`.
Para las funciones de Go implementadas que utilizan un [paquete de implementación .zip](golang-package.md), el archivo ejecutable que contiene el código de la función debe tener el nombre `bootstrap`. Además, el archivo `bootstrap` debe estar en la raíz del archivo .zip. Para las funciones de Go que utilizan una [imagen de contenedor](go-image.md#go-image-provided), puede utilizar cualquier nombre para el archivo ejecutable.
## Definición del objeto de evento de entrada y acceso a él
El formato de entrada más común y estándar de las funciones de Lambda es JSON. En este ejemplo, la función espera una entrada similar a la siguiente:
```
{
"order_id": "12345",
"amount": 199.99,
"item": "Wireless Headphones"
}
```
Al trabajar con funciones de Lambda en Go, puede definir la forma del evento de entrada esperado como una estructura de Go. En este ejemplo, definimos una estructura para representar `Order`:
```
type Order struct {
OrderID string `json:"order_id"`
Amount float64 `json:"amount"`
Item string `json:"item"`
}
```
Esta estructura coincide con la forma de entrada esperada. Después de definir la estructura, puede escribir una firma de controlador que incluya un tipo de JSON genérico compatible con la [biblioteca estándar encoding/json](https://pkg.go.dev/encoding/json). A continuación, puede deserializarla en la estructura mediante la función [func Unmarshal](https://golang.org/pkg/encoding/json/#Unmarshal). Esto se ilustra en las primeras líneas del controlador:
```
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
...
}
```
Tras esta deserialización, puede acceder a los campos de la variable `order`. Por ejemplo, `order.OrderID` recupera el valor de `"order_id"` de la entrada original.
**nota**
El paquete `encoding/json` solo puede acceder a los campos exportados. Para que se exporten, los nombres de campo en la estructura de eventos deben estar en mayúsculas.
## Acceso y uso del objeto de contexto de Lambda
El [objeto de contexto](golang-context.md) de Lambda contiene información sobre la invocación, la función y el entorno de ejecución. En este ejemplo, declaramos esta variable como `ctx` en la firma del controlador:
```
func handleRequest(ctx context.Context, event json.RawMessage) error {
...
}
```
La entrada `ctx context.Context` es un argumento opcional en el controlador de funciones. Para obtener más información sobre las firmas de controlador aceptadas, consulte [Firmas de controlador válidas para los controladores de Go](#golang-handler-signatures).
Si hace llamadas a otros servicios mediante el AWS SDK, el objeto de contexto es obligatorio en algunas áreas clave. Por ejemplo, para inicializar correctamente los clientes del SDK, puede cargar la configuración correcta del AWS SDK mediante el objeto de contexto de la siguiente manera:
```
// Load AWS SDK configuration using the default credential provider chain
cfg, err := config.LoadDefaultConfig(ctx)
```
Las propias llamadas al SDK pueden requerir el objeto de contexto como entrada. Por ejemplo, la llamada `s3Client.PutObject` acepta el objeto de contexto como primer argumento:
```
// Upload the receipt to S3
_, err = s3Client.PutObject(ctx, &s3.PutObjectInput{
...
})
```
Además de las solicitudes del AWS SDK, también puede usar el objeto de contexto para supervisar las funciones. Para obtener más información acerca del objeto de contexto, consulte [Uso del objeto de contexto Lambda para recuperar la información de la función Go](golang-context.md).
## Firmas de controlador válidas para los controladores de Go
Al crear un controlador de funciones de Lambda en Go tiene varias opciones, pero debe cumplir las reglas siguientes:
+ El controlador debe ser una función.
+ El controlador puede aceptar entre 0 y 2 argumentos. Si hay dos argumentos, el primero debe implementar `context.Context`.
+ El controlador puede devolver entre 0 y 2 argumentos. Si hay un único valor de retorno, este debe implementar `error`. Si hay dos valores de retorno, el segundo debe implementar `error`.
A continuación se enumeran las firmas de controlador válidas. `TIn` y `TOut` representan los tipos compatibles con la biblioteca estándar *encoding/json*. Para obtener más información, consulte [func Unmarshal](https://golang.org/pkg/encoding/json/#Unmarshal) a fin de saber cómo se deserializan estos tipos.
+
```
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 de la versión 2 de AWS SDK para Go en el controlador
A menudo, utilizará las funciones de Lambda para interactuar con otros recursos de AWS o actualizarlos. La forma más sencilla de interactuar con estos recursos es utilizar la [versión 2 de AWS SDK para Go](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2).
**nota**
La versión 1 de AWS SDK para Go está en modo de mantenimiento y está previsto que deje de ser compatible el 31 de julio de 2025. Le recomendamos que utilice únicamente la versión 2 de AWS SDK para Go ahora en adelante.
Para agregar dependencias del SDK a la función, utilice el comando `go get` para los clientes del SDK específicos que necesite. En el código de ejemplo anterior, utilizamos la biblioteca `config` y la biblioteca `s3`. Para agregar estas dependencias, ejecute los siguientes comandos en el directorio que contiene los archivos `go.mod` y `main.go `:
```
go get github.com/aws/aws-sdk-go-v2/config
go get github.com/aws/aws-sdk-go-v2/service/s3
```
A continuación, importe las dependencias en consecuencia en el bloque import de la función:
```
import (
...
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/s3"
)
```
Al utilizar el SDK en el controlador, configure los clientes con los ajustes correctos. La forma más sencilla de hacerlo es utilizar la [cadena de proveedores de credenciales predeterminada](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html#credentialProviderChain). Este ejemplo ilustra una forma de cargar esta configuración:
```
// 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
}
```
Después de cargar esta configuración en la variable `cfg`, puede pasarla a las instancias del cliente. El código de ejemplo crea una instancia de un cliente de Amazon S3 de la siguiente manera:
```
// Create an S3 client
s3Client := s3.NewFromConfig(cfg)
```
En este ejemplo, inicializamos el cliente de Amazon S3 en la función `init()` para evitar tener que inicializarlo cada vez que invocamos nuestra función. El problema es que Lambda no tiene acceso al objeto de contexto en la función `init()`. Como solución alternativa, puede pasar un marcador de posición, como `context.TODO()`, durante la fase de inicialización. Más adelante, cuando haga una llamada con el cliente, pase el objeto de contexto completo. Esta solución alternativa también se describe en [Uso del contexto en las llamadas e inicializaciones de los clientes del AWS SDK](golang-context.md#golang-context-sdk).
Después de configurar e inicializar el cliente del SDK, podrá usarlo para interactuar con otros servicios de AWS. El código de ejemplo llama a la API `PutObject` de Amazon S3 de la siguiente manera:
```
_, err = s3Client.PutObject(ctx, &s3.PutObjectInput{
Bucket: &bucketName,
Key: &key,
Body: strings.NewReader(receiptContent),
})
```
## Acceso a las variables de entorno
En el código del controlador, puede hacer referencia a cualquier [variable de entorno](configuration-envvars.md) mediante el método `os.Getenv()`. En este ejemplo, hacemos referencia a la variable de entorno `RECEIPT_BUCKET` definida mediante la siguiente línea 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")
}
```
## Uso del estado global
Para evitar la creación de nuevos recursos cada vez que se invoque la función, puede declarar y modificar variables globales fuera del código del controlador de la función de Lambda. Estas variables globales se definen en una instrucción o un bloque `var`. Además, el controlador puede declarar una función `init()` que se ejecute durante la [fase de inicialización](lambda-runtime-environment.md#runtimes-lifecycle-ib). El método `init` se comporta del mismo modo en AWS Lambda que en los programas de Go estándar.
## Prácticas recomendadas de codificación para las funciones de Lambda en Go
Siga las directrices de la siguiente lista para utilizar las prácticas recomendadas de codificación al crear sus funciones de Lambda:
+ **Separe el controlador de Lambda de la lógica del núcleo.** Esto le permite probar las distintas unidades de la función con mayor facilidad.
+ **Minimice la complejidad de las dependencias.** Son preferibles los marcos de trabajo más sencillos, ya que se cargan rápidamente al arrancar el [entorno de ejecución](lambda-runtime-environment.md).
+ **Minimice el tamaño del paquete de implementación de acuerdo con las necesidades de su tiempo de ejecución.** Esto reducirá la cantidad de tiempo que tarda el paquete de implementación en descargarse y desempaquetarse antes de la invocación.
**Reutilice el entorno de ejecución para mejorar el rendimiento de la función.** Inicialice los clientes de SDK y las conexiones de base de datos fuera del controlador de funciones y almacene localmente en caché los recursos estáticos en el directorio `/tmp`. Las invocaciones posteriores procesadas por la misma instancia de su función pueden reutilizar estos recursos. Esto ahorra costes al reducir el tiempo de ejecución de la función.
Para evitar posibles filtraciones de datos entre las invocaciones, no utilice el entorno de ejecución para almacenar datos de usuario, eventos u otra información con implicaciones de seguridad. Si su función se basa en un estado mutable que no se puede almacenar en la memoria dentro del controlador, considere crear una función independiente o versiones independientes de una función para cada usuario.
**Utilice una directiva keep-alive para mantener conexiones persistentes.** Lambda purga las conexiones inactivas a lo largo del tiempo. Si intenta reutilizar una conexión inactiva al invocar una función, se producirá un error de conexión. Para mantener la conexión persistente, use la directiva keep-alive asociada al tiempo de ejecución. Para ver un ejemplo, consulte [Reutilización de conexiones con Keep-Alive en Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html).
**Utilice [variables de entorno](configuration-envvars.md) para pasar parámetros operativos a su función.** Por ejemplo, si está escribiendo en un bucket de Amazon S3, en lugar de codificar de forma rígida el nombre del bucket, configúrelo como una variable de entorno.
**Evite utilizar invocaciones recursivas** en la función de Lambda, en las que la función se invoca a sí misma o inicia un proceso que puede volver a invocarla. Esto podría producir un volumen no intencionado de invocaciones de la función y costos elevados. Si observa un volumen imprevisto de invocaciones, establezca la simultaneidad reservada de funciones en `0` inmediatamente para limitar todas las invocaciones de la función mientras actualiza el código.
**No utilice API no documentadas y no públicas** en el código de la función de Lambda. Para tiempos de ejecución administrados de AWS Lambda, Lambda aplica periódicamente actualizaciones funcionales y de seguridad a las API internas de Lambda. Estas actualizaciones de las API internas pueden ser incompatibles con versiones anteriores, lo que conlleva consecuencias no deseadas, como errores de invocación si su función depende de estas API no públicas. Consulte la [referencia de la API](https://docs.aws.amazon.com/lambda/latest/api/welcome.html) para obtener una lista de las API disponibles públicamente.
**Escriba el código idempotente.** Escribir el código idempotente para las funciones garantiza que los eventos duplicados se gestionen de la misma manera. El código debe validar y gestionar correctamente los eventos duplicados. Para obtener más información, consulte [¿Cómo puedo hacer que mi función de Lambda sea idempotente?](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-function-idempotent/).
# Uso del objeto de contexto Lambda para recuperar la información de la función Go
En Lambda, el objeto de contexto proporciona métodos y propiedades con información acerca de la invocación, la función y el entorno de ejecución. Cuando Lambda ejecuta su función, pasa un objeto context al [controlador](golang-handler.md). Para usar el objeto de contexto en el controlador, puede declararlo opcionalmente como un parámetro de entrada para el controlador. El objeto de contexto es necesario si desea hacer lo siguiente en el controlador:
+ Necesita acceder a cualquier [variable, método o propiedad global](#golang-context-library) que ofrece el objeto de contexto. Estos métodos y propiedades son útiles para tareas como determinar la entidad que invocó la función o medir el tiempo de invocación de la función, como se muestra en [Acceso a la información del contexto de invocación](#golang-context-access).
+ Debe utilizar AWS SDK para Go para hacer llamadas a otros servicios. El objeto de contexto es un parámetro de entrada importante para la mayoría de estas llamadas. Para obtener más información, consulte [Uso del contexto en las llamadas e inicializaciones de los clientes del AWS SDK](#golang-context-sdk).
**Topics**
+ [Variables, métodos y propiedades compatibles en el objeto de contexto](#golang-context-library)
+ [Acceso a la información del contexto de invocación](#golang-context-access)
+ [Uso del contexto en las llamadas e inicializaciones de los clientes del AWS SDK](#golang-context-sdk)
## Variables, métodos y propiedades compatibles en el objeto de contexto
La biblioteca de contexto de Lambda proporciona las siguientes variables globales, métodos y propiedades.
**Variables globales**
+ `FunctionName`: el nombre de la función de Lambda.
+ `FunctionVersion`: la [versión](configuration-versions.md) de la función.
+ `MemoryLimitInMB`: cantidad de memoria asignada a la función.
+ `LogGroupName`: el grupo de registros de para la función.
+ `LogStreamName`: el flujo de registro de la instancia de la función.
**Métodos de context**
+ `Deadline`: devuelve la fecha en la que la ejecución agota su tiempo de espera, en milisegundos de tiempo Unix.
**Propiedades de context**
+ `InvokedFunctionArn`: el nombre de recurso de Amazon (ARN) que se utiliza para invocar la función. Indica si el invocador especificó un número de versión o alias.
+ `AwsRequestID`: el identificador de la solicitud de invocación.
+ `Identity`: (aplicaciones móviles) Información acerca de la identidad de Amazon Cognito que autorizó la solicitud.
+ `ClientContext`: (aplicaciones móviles) Contexto de cliente proporcionado a Lambda por la aplicación cliente.
## Acceso a la información del contexto de invocación
Las funciones de Lambda tienen acceso a metadatos acerca de su entorno y la solicitud de invocación. Se puede obtener acceso en el [contexto del paquete](https://golang.org/pkg/context/). Si el controlador incluye `context.Context` como parámetro, Lambda información acerca de su función en la propiedad `Value` del contexto. Tenga en cuenta que debe importar la biblioteca `lambdacontext` para obtener acceso al contenido del 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)
}
```
En el ejemplo anterior, `lc` es la variable que se usa para consumir la información que el objeto context capturó y `log.Print(lc.Identity.CognitoIdentityPoolID)` imprime dicha información, en este caso, CognitoIdentityPoolID.
En el ejemplo siguiente se indica cómo utilizar el objeto context para monitorear el tiempo que tarda en ejecutarse la función de Lambda. Esto le permite analizar las expectativas de desempeño y ajustar el código de su función en consecuencia, si es necesario.
```
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 del contexto en las llamadas e inicializaciones de los clientes del AWS SDK
Si el controlador necesita usar AWS SDK para Go para hacer llamadas a otros servicios, incluya el objeto de contexto como entrada para el controlador. En AWS, una práctica recomendada es pasar el objeto de contexto en la mayoría de las llamadas al AWS SDK. Por ejemplo, la llamada `PutObject` a Amazon S3 acepta el objeto de contexto (`ctx`) como primer argumento:
```
// Upload an object to S3
_, err = s3Client.PutObject(ctx, &s3.PutObjectInput{
...
})
```
Para inicializar los clientes del SDK correctamente, también puede usar el objeto de contexto para cargar la configuración correcta antes de pasar ese objeto de configuración al cliente:
```
// Load AWS SDK configuration using the default credential provider chain
cfg, err := config.LoadDefaultConfig(ctx)
...
s3Client = s3.NewFromConfig(cfg)
```
Si quiere inicializar los clientes del SDK fuera del controlador principal (es decir, durante la fase de inicialización), puede pasar un objeto de contexto de marcador de posición:
```
func init() {
// Initialize the S3 client outside of the handler, during the init phase
cfg, err := config.LoadDefaultConfig(context.TODO())
...
s3Client = s3.NewFromConfig(cfg)
}
```
Si inicializa los clientes de esta manera, asegúrese de pasar el objeto de contexto correcto en las llamadas al SDK desde el controlador principal.
# Implementar funciones de Lambda en Go con archivos .zip
El código de la función AWS Lambda se compone de scripts o programas compilados y sus dependencias. Utiliza un *paquete de implementación* para implementar su código de función en Lambda. Lambda admite dos tipos de paquetes de implementación: imágenes de contenedor y archivos .zip.
En esta página se describe cómo crear un archivo .zip como paquete de despliegue para el tiempo de ejecución de Go y, a continuación, utilizar el archivo .zip para implementar el código de función con AWS Lambda mediante la Consola de administración de AWS, la AWS Command Line Interface (AWS CLI) y AWS Serverless Application Model (AWS SAM).
Lambda usa permisos de archivo de POSIX, por lo que puede necesitar [establecer permisos para la carpeta del paquete de despliegue](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-deployment-package-errors/) antes de crear el archivo .zip.
**Topics**
+ [Creación de un archivo.zip en macOS y Linux](#golang-package-mac-linux)
+ [Crear un archivo.zip en Windows](#golang-package-windows)
+ [Creación y actualización de funciones de Lambda en Go mediante archivos .zip](#golang-package-create-function)
## Creación de un archivo.zip en macOS y Linux
En los siguientes pasos, se muestra cómo compilar el archivo ejecutable mediante el comando `go build` y crear un paquete de implementación de archivos .zip para Lambda. Antes de compilar el código, asegúrese de haber instalado el paquete [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda) de GitHub. Este módulo proporciona una implementación de la interfaz del tiempo de ejecución que administra la interacción entre Lambda y el código de la función. Para descargarla, ejecute el siguiente comando.
```
go get github.com/aws/aws-lambda-go/lambda
```
Si su función usa AWS SDK para Go, descargue el conjunto estándar de módulos del SDK, junto con los clientes de API de servicio de AWS que requiera su aplicación. Para obtener información sobre cómo instalar el SDK para Go, consulte [Getting Started with the AWS SDK para Go V2](https://github.com/aws/aws-sdk-go-v2?tab=readme-ov-file#getting-started).
### Uso de la familia de tiempo de ejecución proporcionada
Go se implementa de manera distinta a otros tiempos de ejecución administrados. Como Go se compila de forma nativa en un archivo binario ejecutable, no requiere un tiempo de ejecución de lenguaje dedicado. Utilice un [tiempo de ejecución exclusivo para el sistema operativo](runtimes-provided.md) (la familia de tiempos de ejecución `provided`) para implementar las funciones de Go en Lambda.
**Para crear un paquete de paquete de implementación .zip (macOS o Linux)**
1. En el directorio del proyecto que contiene el archivo `main.go` de la aplicación, compile el ejecutable. Tenga en cuenta lo siguiente:
+ El ejecutable debe denominarse `bootstrap`. Para obtener más información, consulte [Convenciones de nomenclatura de controladores](golang-handler.md#golang-handler-naming).
+ Establezca su [arquitectura del conjunto de instrucciones](foundation-arch.md) de destino. El tiempo de ejecución de OS solo admite arm64 y x86\$164.
+ Puede utilizar la etiqueta opcional `lambda.norpc` para excluir el componente de llamada a procedimiento remoto (RPC) de la biblioteca [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda). El componente de RPC solo es necesario si utiliza el tiempo de ejecución obsoleto Go 1.x. La exclusión del RPC reduce el tamaño del paquete de implementación.
Para la arquitectura arm64:
```
GOOS=linux GOARCH=arm64 go build -tags lambda.norpc -o bootstrap main.go
```
Para la arquitectura x86\$164:
```
GOOS=linux GOARCH=amd64 go build -tags lambda.norpc -o bootstrap main.go
```
1. (Opcional) Es posible que necesite compilar paquetes con `CGO_ENABLED=0` establecido en Linux:
```
GOOS=linux GOARCH=arm64 CGO_ENABLED=0 go build -o bootstrap -tags lambda.norpc main.go
```
Este comando crea un paquete binario estable para las versiones estándar de la biblioteca de C (`libc`), que puede ser diferente en Lambda y en otros dispositivos.
1. Empaquete el ejecutable en un archivo.zip para crear un paquete de implementación.
```
zip myFunction.zip bootstrap
```
**nota**
El archivo `bootstrap` debe estar en la raíz del archivo.zip.
1. Cree la función. Tenga en cuenta lo siguiente:
+ El binario debe tener un nombre `bootstrap`, pero el nombre del controlador puede ser cualquier cosa. Para obtener más información, consulte [Convenciones de nomenclatura de controladores](golang-handler.md#golang-handler-naming).
+ La opción `--architectures` es obligatoria si utiliza arm64. El valor predeterminado es x86\$164.
+ Para `--role`, especifique el Nombre de recurso de Amazon (ARN) del [rol de ejecución](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
```
## Crear un archivo.zip en Windows
En los siguientes pasos, se muestra cómo descargar la herramienta [build-lambda-zip](https://github.com/aws/aws-lambda-go/tree/main/cmd/build-lambda-zip) para Windows desde GitHub, compilar el archivo ejecutable y crear un paquete de despliegue .zip.
**nota**
Si aún no lo ha hecho, debe instalar [git](https://git-scm.com/) y luego agregar el `git` ejecutable a su variable de `%PATH%` entorno de Windows.
Antes de compilar el código, asegúrese de haber instalado la biblioteca [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda) desde GitHub. Para descargarla, ejecute el siguiente comando.
```
go get github.com/aws/aws-lambda-go/lambda
```
Si su función usa AWS SDK para Go, descargue el conjunto estándar de módulos del SDK, junto con los clientes de API de servicio de AWS que requiera su aplicación. Para obtener información sobre cómo instalar el SDK para Go, consulte [Getting Started with the AWS SDK para Go V2](https://aws.github.io/aws-sdk-go-v2/docs/getting-started/).
### Uso de la familia de tiempo de ejecución proporcionada
Go se implementa de manera distinta a otros tiempos de ejecución administrados. Como Go se compila de forma nativa en un archivo binario ejecutable, no requiere un tiempo de ejecución de lenguaje dedicado. Utilice un [tiempo de ejecución exclusivo para el sistema operativo](runtimes-provided.md) (la familia de tiempos de ejecución `provided`) para implementar las funciones de Go en Lambda.
**Para crear un paquete de implementación .zip (Windows)**
1. Descargue la herramienta **build-lambda-zip** de GitHub.
```
go install github.com/aws/aws-lambda-go/cmd/build-lambda-zip@latest
```
1. Utilice la herramienta desde `GOPATH` para crear un archivo .zip. Si tiene una instalación predeterminada de Go, la herramienta suele estar en `%USERPROFILE%\Go\bin`. De lo contrario, vaya hasta la ubicación donde instaló el tiempo de ejecución de Go y haga una de las siguientes acciones:
------
#### [ cmd.exe ]
En cmd.exe, ejecute una de las siguientes opciones, según su [arquitectura del conjunto de instrucciones](foundation-arch.md) de destino. El tiempo de ejecución de OS solo admite arm64 y x86\$164.
Puede utilizar la etiqueta opcional `lambda.norpc` para excluir el componente de llamada a procedimiento remoto (RPC) de la biblioteca [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda). El componente de RPC solo es necesario si utiliza el tiempo de ejecución obsoleto Go 1.x. La exclusión del RPC reduce el tamaño del paquete de implementación.
**Example — Para la arquitectura 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 la arquitectura 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 ]
En PowerShell, ejecute una de las siguientes opciones, según su [arquitectura del conjunto de instrucciones](foundation-arch.md) de destino. El tiempo de ejecución de SO solo admite arm64 y x86\$164.
Puede utilizar la etiqueta opcional `lambda.norpc` para excluir el componente de llamada a procedimiento remoto (RPC) de la biblioteca [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda). El componente de RPC solo es necesario si utiliza el tiempo de ejecución obsoleto Go 1.x. La exclusión del RPC reduce el tamaño del paquete de implementación.
Para la arquitectura 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 la arquitectura 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. Cree la función. Tenga en cuenta lo siguiente:
+ El binario debe tener un nombre `bootstrap`, pero el nombre del controlador puede ser cualquier cosa. Para obtener más información, consulte [Convenciones de nomenclatura de controladores](golang-handler.md#golang-handler-naming).
+ La opción `--architectures` es obligatoria si utiliza arm64. El valor predeterminado es x86\$164.
+ Para `--role`, especifique el Nombre de recurso de Amazon (ARN) del [rol de ejecución](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
```
## Creación y actualización de funciones de Lambda en Go mediante archivos .zip
Una vez que haya creado su paquete de implementación .zip, puede utilizarlo para crear una nueva función de Lambda o actualizar una existente. Puede implementar el paquete .zip a través de la consola, la AWS Command Line Interface y la API de Lambda. También puede crear y actualizar funciones de Lambda mediante AWS Serverless Application Model (AWS SAM) y CloudFormation.
El tamaño máximo de un paquete de despliegue .zip para Lambda es de 250 MB (descomprimido). Tenga en cuenta que este límite se aplica al tamaño combinado de todos los archivos que cargue, incluidas las capas de Lambda.
El tiempo de ejecución de Lambda necesita permiso para leer los archivos del paquete de implementación. En la notación octal de permisos de Linux, Lambda necesita 644 permisos para archivos no ejecutables (rw-r--r--) y 755 permisos (rwxr-xr-x) para directorios y archivos ejecutables.
En Linux y macOS, utilice el comando `chmod` para cambiar los permisos de los archivos y directorios del paquete de implementación. Por ejemplo, para conceder a un archivo no ejecutable los permisos correctos, ejecute el siguiente comando.
```
chmod 644
```
Para cambiar los permisos de los archivos en 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)) en la documentación de Microsoft Windows.
**nota**
Si no concede a Lambda los permisos necesarios para acceder a los directorios del paquete de implementación, Lambda establecerá los permisos de esos directorios en 755 (rwxr-xr-x).
### Creación y actualización de funciones con archivos .zip mediante la consola
Para crear una nueva función, primero debe crearla en la consola y, a continuación, cargar el archivo .zip. Para actualizar una función existente, abra la página de la función correspondiente y, a continuación, siga el mismo procedimiento para agregar el archivo .zip actualizado.
Si el archivo .zip tiene un tamaño inferior a 50 MB, puede crear o actualizar una función al cargarlo directamente desde su equipo local. Para archivos .zip de más de 50 MB, primero debe cargar su paquete en un bucket de Amazon S3. Para obtener instrucciones sobre cómo cargar un archivo en un bucket de Amazon S3 con la Consola de administración de AWS, consulte [Introducción a Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html). Para cargar archivos mediante la AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) en la *Guía del usuario de la AWS CLI*.
**nota**
No se puede convertir una función de imagen de contenedor existente para utilizar un archivo .zip. Debe crear una nueva función.
**Para crear una nueva función (consola)**
1. Abra la [página Funciones](https://console.aws.amazon.com/lambda/home#/functions) de la consola de Lambda y elija **Crear función**.
1. Elija **Crear desde cero**.
1. En **Información básica**, haga lo siguiente:
1. En **Nombre de función**, escriba el nombre de la función.
1. En **Runtime (Tiempo de ejecución)**, elija `provided.al2023`.
1. (Opcional) En **Permisos**, expanda **Cambiar función de ejecución predeterminada**. Puede crear un nuevo **Rol de ejecución** o utilizar uno existente.
1. Seleccione **Creación de función**. Lambda crea una función básica “Hola, mundo” mediante el tiempo de ejecución elegido.
**Para cargar un archivo .zip desde su equipo local (consola)**
1. En la [página Funciones](https://console.aws.amazon.com/lambda/home#/functions) de la consola de Lambda, elija la función para la que desea cargar el archivo .zip.
1. Seleccione la pestaña **Código**.
1. En el panel **Código fuente**, elija **Cargar desde**.
1. Elija un **archivo .zip**.
1. Para cargar el archivo .zip, haga lo siguiente:
1. Seleccione **Cargar** y, a continuación, seleccione su archivo .zip en el selector de archivos.
1. Elija **Abrir**.
1. Seleccione **Save**.
**Carga de un archivo .zip desde un bucket de Amazon S3 (consola)**
1. En la [página Funciones](https://console.aws.amazon.com/lambda/home#/functions) de la consola de Lambda, elija la función para la que desea cargar un nuevo archivo .zip.
1. Seleccione la pestaña **Código**.
1. En el panel **Código fuente**, elija **Cargar desde**.
1. Elija la **ubicación de Amazon S3**.
1. Pegue la URL del enlace de Amazon S3 de su archivo .zip y seleccione **Guardar**.
### Creación y actualización de funciones con archivos .zip mediante la AWS CLI
Puede utilizar la [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) para crear una nueva función o actualizar una existente con un archivo .zip. Utilice los comandos [create-function](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) y [update-function-code](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) para implementar su paquete .zip. Si el archivo .zip tiene un tamaño inferior a 50 MB, puede cargarlo desde una ubicación de archivo en su equipo de compilación local. Para archivos más grandes, debe cargar su paquete .zip desde un bucket de Amazon S3. Para obtener instrucciones sobre cómo cargar un archivo en un bucket de Amazon S3 con la AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) en la *Guía del usuario de la AWS CLI*.
**nota**
Si carga su archivo .zip desde un bucket de Amazon S3 con la AWS CLI, el bucket debe estar ubicado en la misma Región de AWS que su función.
Para crear una nueva función mediante un archivo .zip con la AWS CLI, debe especificar lo siguiente:
+ El nombre de la función (`--function-name`).
+ El tiempo de ejecución de la función (`--runtime`).
+ El nombre de recurso de Amazon (ARN) del [rol de ejecución](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) de la función (`--role`).
+ El nombre del método de controlador en el código de la función (`--handler`).
También debe especificar la ubicación del archivo .zip. Si el archivo .zip se encuentra en una carpeta de su equipo de compilación local, utilice la opción `--zip-file` para especificar la ruta del archivo, como se muestra en el siguiente comando de ejemplo.
```
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 la ubicación del archivo .zip en un bucket de Amazon S3, utilice la opción `--code`, como se muestra en el siguiente comando de ejemplo. Solo necesita utilizar el parámetro `S3ObjectVersion` para los objetos con versiones.
```
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 actualizar una función existente mediante la CLI, especifique el nombre de la función mediante el parámetro `--function-name`. También debe especificar la ubicación del archivo .zip que desea utilizar para actualizar el código de la función. Si el archivo .zip se encuentra en una carpeta de su equipo de compilación local, utilice la opción `--zip-file` para especificar la ruta del archivo, como se muestra en el siguiente comando de ejemplo.
```
aws lambda update-function-code --function-name myFunction \
--zip-file fileb://myFunction.zip
```
Para especificar la ubicación del archivo .zip en un bucket de Amazon S3, utilice las opciones `--s3-bucket` y `--s3-key` tal como se muestra en el siguiente comando de ejemplo. Solo necesita utilizar el parámetro `--s3-object-version` para los objetos con versiones.
```
aws lambda update-function-code --function-name myFunction \
--s3-bucket amzn-s3-demo-bucket --s3-key myFileName.zip --s3-object-version myObject Version
```
### Creación y actualización de funciones con archivos .zip mediante la API de Lambda
Para crear y actualizar funciones con un archivo de archivos .zip, utilice las siguientes operaciones de la 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)
### Creación y actualización de funciones con archivos .zip mediante AWS SAM
AWS Serverless Application Model (AWS SAM) es un conjunto de herramientas que ayuda a agilizar el proceso de creación y ejecución de aplicaciones sin servidor en AWS. Defina los recursos de su aplicación en una plantilla YAML o JSON y utilice la interfaz de la línea de comandos de AWS SAM (AWS SAM CLI) para crear, empaquetar e implementar sus aplicaciones. Al crear una función de Lambda a partir de una plantilla de AWS SAM, AWS SAM crea automáticamente un paquete de despliegue .zip o una imagen de contenedor con el código de la función y las dependencias que especifique. Para obtener más información sobre el uso de AWS SAM para crear e implementar funciones de Lambda, consulte [Introducción a AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) en la *Guía para desarrolladores de AWS Serverless Application Model*.
También puede utilizar AWS SAM para crear una función de Lambda con un archivo de archivos .zip existente. Para crear una función de Lambda mediante AWS SAM, puede guardar el archivo .zip en un bucket de Amazon S3 o en una carpeta local de su equipo de compilación. Para obtener instrucciones sobre cómo cargar un archivo en un bucket de Amazon S3 con la AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) en la *Guía del usuario de la AWS CLI*.
En la plantilla de AWS SAM, el recurso `AWS::Serverless::Function` especifica la función de Lambda. En este recurso, establezca las siguientes propiedades para crear una función mediante un archivo de archivos .zip:
+ `PackageType`: se establece como `Zip`.
+ `CodeUri`: se establece como el URI de Amazon S3, la ruta a la carpeta local o el objeto [FunctionCode](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-functioncode.html) del código de la función.
+ `Runtime`: se establece como el entorno de ejecución elegido
Con AWS SAM, si su archivo .zip tiene más de 50 MB, no es necesario cargarlo primero en un bucket de Amazon S3. AWS SAM puede cargar paquetes .zip hasta el tamaño máximo permitido de 250 MB (descomprimidos) desde una ubicación de su equipo de compilación local.
Para obtener más información sobre la implementación de funciones mediante un archivo .zip en AWS SAM, consulte [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html) en la *Guía para desarrolladores de AWS SAM*.
**Ejemplo: uso de AWS SAM para crear una función de Go con provided.al2023**
1. Cree una plantilla de AWS SAM con las propiedades siguientes:
+ **BuildMethod**: especifica el compilador de la aplicación. Utilice `go1.x`.
+ **Tiempo de ejecución**: use `provided.al2023`.
+ **CodeUri**: ingrese la ruta de su código.
+ **Arquitecturas**: use `[arm64]` para la arquitectura arm64. Use `[amd64]` o elimine la propiedad `Architectures` para la arquitectura del conjunto de instrucciones x86\$164.
**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. Utilice el comando [sam build](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-build.html) para compilar el ejecutable.
```
sam build
```
1. Utilice el comando [sam deploy](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html) para implementar la función en Lambda.
```
sam deploy --guided
```
### Creación y actualización de funciones con archivos .zip mediante CloudFormation
Puede utilizar CloudFormation para crear una función de Lambda con un archivo de archivos .zip. Para crear una función de Lambda a partir de un archivo .zip, primero debe cargar el archivo a un bucket de Amazon S3. Para obtener instrucciones sobre cómo cargar un archivo en un bucket de Amazon S3 con la AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) en la *Guía del usuario de la AWS CLI.*
En la plantilla de CloudFormation, el recurso `AWS::Lambda::Function` especifica la función de Lambda. En este recurso, establezca las siguientes propiedades para crear una función mediante un archivo de archivos .zip:
+ `PackageType`: se establece como `Zip`.
+ `Code`: ingrese el nombre del bucket de Amazon S3 y el nombre del archivo .zip en los campos `S3Bucket` y `S3Key`.
+ `Runtime`: se establece como el entorno de ejecución elegido
El archivo .zip que genera CloudFormation no puede superar los 4 MB. Para obtener más información sobre la implementación de funciones mediante un archivo .zip en CloudFormation, consulte [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html) en la *Guía del usuario de CloudFormation*.
# Implemente funciones Go Lambda con imágenes de contenedor
Hay dos formas de compilar una imagen de contenedor para una función de Lambda en Go:
+ [Uso de una imagen base exclusiva del sistema operativo de AWS](#go-image-provided)
Go se implementa de manera distinta a otros tiempos de ejecución administrados. Como Go se compila de forma nativa en un archivo binario ejecutable, no requiere un tiempo de ejecución de lenguaje dedicado. Utilice una [imagen base exclusiva para el sistema operativo](images-create.md#runtimes-images-provided) para crear imágenes de Go para Lambda. Para que la imagen sea compatible con Lambda, debe incluir el paquete `aws-lambda-go/lambda` en la imagen.
+ [Uso de una imagen base que no sea de AWS](#go-image-other)
Puede utilizar una imagen base alternativa de otro registro de contenedores, como Alpine Linux o Debian. También puede utilizar una imagen personalizada creada por su organización. Para que la imagen sea compatible con Lambda, debe incluir el paquete `aws-lambda-go/lambda` en la imagen.
**sugerencia**
Para reducir el tiempo que tardan las funciones de contenedor de Lambda en activarse, consulte [Uso de compilaciones de varias fases](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#use-multi-stage-builds) en la documentación de Docker. Para compilar imágenes de contenedores eficientes, siga [Prácticas recomendadas para escribir Dockerfiles](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).
En esta página, se explica cómo compilar, probar e implementar imágenes de contenedor para Lambda.
## Imágenes base de AWS para implementar funciones de Go
Go se implementa de manera distinta a otros tiempos de ejecución administrados. Como Go se compila de forma nativa en un archivo binario ejecutable, no requiere un tiempo de ejecución de lenguaje dedicado. Utilice una [imagen base exclusiva para el sistema operativo](images-create.md#runtimes-images-provided) para implementar funciones de Go en Lambda.
| Nombre | Identificador | Sistema operativo | Fecha de baja | Bloqueo de la función Crear | Bloqueo de la función Actualizar |
| --- | --- | --- | --- | --- | --- |
| Tiempo de ejecución exclusivo del sistema operativo | `provided.al2023` | Amazon Linux 2023 | 30 de junio de 2029 | 31 de julio de 2029 | 31 de agosto de 2029 |
| Tiempo de ejecución exclusivo del sistema operativo | `provided.al2` | Amazon Linux 2 | 31 de julio de 2026 | 31 de agosto de 2026 | 30 de septiembre de 2026 |
Galería pública de Amazon Elastic Container Registry: [gallery.ecr.aws/lambda/provided](https://gallery.ecr.aws/lambda/provided)
## Cliente de interfaz de tiempo de ejecución de Go
El paquete `aws-lambda-go/lambda` incluye una implementación de la interfaz de tiempo de ejecución. Para ver ejemplos de cómo usar `aws-lambda-go/lambda` en la imagen, consulte [Uso de una imagen base exclusiva del sistema operativo de AWS](#go-image-provided) o [Uso de una imagen base que no sea de AWS](#go-image-other).
## Uso de una imagen base exclusiva del sistema operativo de AWS
Go se implementa de manera distinta a otros tiempos de ejecución administrados. Como Go se compila de forma nativa en un archivo binario ejecutable, no requiere un tiempo de ejecución de lenguaje dedicado. Utilice una [imagen base exclusiva para el sistema operativo](images-create.md#runtimes-images-provided) para compilar imágenes de contenedor para funciones de Go.
| Etiquetas | Tiempo de ejecución | Sistema operativo | Dockerfile | Obsolescencia |
| --- | --- | --- | --- | --- |
| al2023 | Tiempo de ejecución exclusivo del sistema operativo | Amazon Linux 2023 | [Dockerfile para tiempo de ejecución exclusivo del sistema operativo en GitHub](https://github.com/aws/aws-lambda-base-images/blob/provided.al2023/Dockerfile.provided.al2023) | 30 de junio de 2029 |
| al2 | Tiempo de ejecución exclusivo del sistema operativo | Amazon Linux 2 | [Dockerfile para tiempo de ejecución exclusivo del sistema operativo en GitHub](https://github.com/aws/aws-lambda-base-images/blob/provided.al2/Dockerfile.provided.al2) | 31 de julio de 2026 |
Para obtener más información acerca de estas imágenes base, consulte [provided](https://gallery.ecr.aws/lambda/provided) en la galería pública de Amazon ECR.
Debe incluir el paquete [aws-lambda-go/lambda](https://github.com/aws/aws-lambda-go) con su controlador de Go. Este paquete implementa el modelo de programación para Go, incluida la interfaz de tiempo de ejecución.
### Requisitos previos
Para completar los pasos de esta sección, debe disponer de lo siguiente:
+ [AWS CLI versión 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versión mínima 25.0.0)
+ El [complemento buildx](https://github.com/docker/buildx/blob/master/README.md) de Docker.
+ Go
### Creación de una imagen a partir de la imagen base provided.al2023
**Para compilar e implementar una función de Go con la imagen base de `provided.al2023`**
1. Cree un directorio para el proyecto y, a continuación, cambie a ese directorio.
```
mkdir hello
cd hello
```
1. Inicialice un nuevo módulo de Go.
```
go mod init example.com/hello-world
```
1. Agregue la biblioteca **lambda** como dependencia de su nuevo módulo.
```
go get github.com/aws/aws-lambda-go/lambda
```
1. Cree un archivo con el nombre `main.go` y, a continuación, ábralo en un editor de texto. Se trata del código de la función de Lambda. Puede utilizar el siguiente código de muestra para realizar pruebas o sustituirlo por su propio 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. Utilice un editor de texto para crear un Dockerfile en el directorio del proyecto.
+ El siguiente Dockerfile de ejemplo utiliza una [compilación de varias etapas](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#use-multi-stage-builds). Esto le permite utilizar una imagen base diferente en cada paso. Puede usar una imagen, como una [imagen base de Go](https://hub.docker.com/_/golang), para compilar el código y crear el binario ejecutable. Luego puede utilizar una imagen diferente, como `provided.al2023`, en la instrucción final `FROM` para definir la imagen que va a implementar en Lambda. El proceso de compilación está separado de la imagen de implementación final, por lo que la imagen final solo contiene los archivos necesarios para ejecutar la aplicación.
+ Puede utilizar la etiqueta opcional `lambda.norpc` para excluir el componente de llamada a procedimiento remoto (RPC) de la biblioteca [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda). El componente de RPC solo es necesario si utiliza el tiempo de ejecución obsoleto Go 1.x. La exclusión del RPC reduce el tamaño del paquete de implementación.
+ Tenga en cuenta que el Dockerfile de ejemplo no incluye una [instrucción USER](https://docs.docker.com/reference/dockerfile/#user). Al implementar una imagen de contenedor en Lambda, Lambda define automáticamente un usuario predeterminado de Linux con permisos de privilegio mínimo. Esto es diferente del comportamiento estándar de Docker, que utiliza de forma predeterminada el usuario `root` cuando no se proporciona ninguna instrucción `USER`.
**Example — Dockerfile de compilación de varias etapas**
**nota**
Asegúrese de que la versión de Go que especifique en su Dockerfile (por ejemplo, `golang:1.20`) sea la misma versión de Go que utilizó para crear su aplicación.
```
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. Compile la imagen de Docker con el comando [docker build](https://docs.docker.com/engine/reference/commandline/build/). En el siguiente ejemplo se asigna un nombre a la imagen `docker-image` y se le asigna la [etiqueta](https://docs.docker.com/engine/reference/commandline/build/#tag) `test`. Para que la imagen sea compatible con Lambda, debe usar la opción `--provenance=false`.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**nota**
El comando especifica la opción `--platform linux/amd64` para garantizar que el contenedor sea compatible con el entorno de ejecución de Lambda, independientemente de la arquitectura de la máquina de compilación. Si tiene intención de crear una función de Lambda con la arquitectura del conjunto de instrucciones ARM64, asegúrese de cambiar el comando para utilizar la opción `--platform linux/arm64` en su lugar.
### (Opcional) Prueba de la imagen de forma local
Utilice el [emulador de interfaz de tiempo de ejecución](https://github.com/aws/aws-lambda-runtime-interface-emulator/) para probar la imagen localmente. El emulador de interfaz de tiempo de ejecución se incluye en la imagen base de `provided.al2023`.
**Para ejecutar el emulador de interfaz de tiempo de ejecución en su equipo local**
1. Inicie la imagen de Docker con el comando **docker run**. Tenga en cuenta lo siguiente:
+ `docker-image` es el nombre de la imagen y `test` es la etiqueta.
+ `./main` es el `ENTRYPOINT` de su Dockerfile.
```
docker run -d -p 9000:8080 \
--entrypoint /usr/local/bin/aws-lambda-rie \
docker-image:test ./main
```
Este comando ejecuta la imagen como un contenedor y crea un punto de conexión local en `localhost:9000/2015-03-31/functions/function/invocations`.
1. Desde una nueva ventana de terminal, publique un evento en el siguiente punto de conexión mediante un comando **curl**:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Este comando invoca la función con un evento vacío y devuelve una respuesta. Es posible que algunas funciones requieran una carga JSON. Ejemplo:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
1. Obtenga el ID del contenedor.
```
docker ps
```
1. Use el comando [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) para detener el contenedor. En este comando, reemplace `3766c4ab331c` por el ID del contenedor del paso anterior.
```
docker kill 3766c4ab331c
```
### Implementación de la imagen
**Para cargar la imagen en Amazon ECR y crear la función de Lambda**
1. Para autenticar la CLI de Docker en su registro de Amazon ECR, ejecute el comando [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html).
+ Establezca el valor de `--region` en la Región de AWS en la que desee crear el repositorio de Amazon ECR.
+ Reemplace `111122223333` por el ID de su Cuenta de 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. Cree un repositorio en Amazon ECR con el 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**
El repositorio de Amazon ECR debe estar en la misma Región de AWS que la función de Lambda.
Si se realiza de la forma correcta, verá una respuesta como la siguiente:
```
{
"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 el valor de `repositoryUri` de la salida del paso anterior.
1. Ejecute el comando [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) para etiquetar la imagen local en su repositorio de Amazon ECR como la versión más reciente. En este comando:
+ `docker-image:test` es el nombre y la [etiqueta](https://docs.docker.com/engine/reference/commandline/build/#tag) de su imagen de Docker. Son el nombre y la etiqueta de la imagen que especificó en el comando `docker build`.
+ Reemplace `` por el `repositoryUri` que ha copiado. Asegúrese de incluir `:latest` al final del URI.
```
docker tag docker-image:test :latest
```
Ejemplo:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Ejecute el comando [docker push](https://docs.docker.com/engine/reference/commandline/push/) para implementar la imagen local en el repositorio de Amazon ECR. Asegúrese de incluir `:latest` al final del URI del repositorio.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Cree un rol de ejecución](lambda-intro-execution-role.md#permissions-executionrole-api) para la función si aún no tiene uno. Necesitará el nombre de recurso de Amazon (ARN) del rol en el paso siguiente.
1. Cree la función de Lambda. En `ImageUri`, especifique el URI del repositorio anterior. Asegúrese de incluir `:latest` al final del 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**
Puede crear una función con una imagen de una cuenta AWS diferente, siempre que la imagen esté en la misma región que la función de Lambda. Para obtener más información, consulte [Permisos entre cuentas de Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Invoque la función.
```
aws lambda invoke --function-name hello-world response.json
```
Debería ver una respuesta como la siguiente:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Para ver la salida de la función, compruebe el archivo `response.json`.
Para actualizar el código de la función, debe volver a compilar la imagen, cargar la nueva imagen en el repositorio de Amazon ECR y, a continuación, utilizar el comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) para implementar la imagen en la función de Lambda.
Lambda resuelve la etiqueta de la imagen en un resumen de imagen específico. Esto significa que si apunta la etiqueta de imagen que se utilizó para implementar la función a una nueva imagen en Amazon ECR, Lambda no actualiza automáticamente la función para usar la nueva imagen.
Para implementar la nueva imagen en la misma función de Lambda, debe usar el comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html), incluso si la etiqueta de la imagen en Amazon ECR sigue siendo la misma. En el siguiente ejemplo, la opción `--publish` crea una nueva versión de la función con la imagen del contenedor actualizada.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
## Uso de una imagen base que no sea de AWS
Puede crear una imagen de contenedor para Go a partir de una imagen base que no es de AWS. El Dockerfile de ejemplo en los siguientes pasos usa una [imagen base de Alpine](https://hub.docker.com/_/golang/).
Debe incluir el paquete [aws-lambda-go/lambda](https://github.com/aws/aws-lambda-go) con su controlador de Go. Este paquete implementa el modelo de programación para Go, incluida la interfaz de tiempo de ejecución.
### Requisitos previos
Para completar los pasos de esta sección, debe disponer de lo siguiente:
+ [AWS CLI versión 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versión mínima 25.0.0)
+ El [complemento buildx](https://github.com/docker/buildx/blob/master/README.md) de Docker.
+ Go
### Creación de imágenes a partir de una imagen base alternativa
**Para crear e implementar una función de Go con una imagen base de Alpine**
1. Cree un directorio para el proyecto y, a continuación, cambie a ese directorio.
```
mkdir hello
cd hello
```
1. Inicialice un nuevo módulo de Go.
```
go mod init example.com/hello-world
```
1. Agregue la biblioteca **lambda** como dependencia de su nuevo módulo.
```
go get github.com/aws/aws-lambda-go/lambda
```
1. Cree un archivo con el nombre `main.go` y, a continuación, ábralo en un editor de texto. Se trata del código de la función de Lambda. Puede utilizar el siguiente código de muestra para realizar pruebas o sustituirlo por su propio 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. Utilice un editor de texto para crear un Dockerfile en el directorio del proyecto. El siguiente Dockerfile de ejemplo usa una [imagen base de Alpine](https://hub.docker.com/_/golang/). Tenga en cuenta que el Dockerfile de ejemplo no incluye una [instrucción USER](https://docs.docker.com/reference/dockerfile/#user). Al implementar una imagen de contenedor en Lambda, Lambda define automáticamente un usuario predeterminado de Linux con permisos de privilegio mínimo. Esto es diferente del comportamiento estándar de Docker, que utiliza de forma predeterminada el usuario `root` cuando no se proporciona ninguna instrucción `USER`.
**Example Dockerfile**
**nota**
Asegúrese de que la versión de Go que especifique en su Dockerfile (por ejemplo, `golang:1.20`) sea la misma versión de Go que utilizó para crear su aplicación.
```
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. Compile la imagen de Docker con el comando [docker build](https://docs.docker.com/engine/reference/commandline/build/). En el siguiente ejemplo se asigna un nombre a la imagen `docker-image` y se le asigna la [etiqueta](https://docs.docker.com/engine/reference/commandline/build/#tag) `test`. Para que la imagen sea compatible con Lambda, debe usar la opción `--provenance=false`.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**nota**
El comando especifica la opción `--platform linux/amd64` para garantizar que el contenedor sea compatible con el entorno de ejecución de Lambda, independientemente de la arquitectura de la máquina de compilación. Si tiene intención de crear una función de Lambda con la arquitectura del conjunto de instrucciones ARM64, asegúrese de cambiar el comando para utilizar la opción `--platform linux/arm64` en su lugar.
### (Opcional) Prueba de la imagen de forma local
Utilice el [emulador de interfaz de tiempo de ejecución](https://github.com/aws/aws-lambda-runtime-interface-emulator/) para probar la imagen localmente. Puede [crear el emulador en su imagen](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#build-rie-into-your-base-image) o usar el procedimiento siguiente para instalarlo en su equipo local.
**Para instalar y ejecutar el emulador de interfaz de tiempo de ejecución en su equipo local**
1. Desde el directorio del proyecto, ejecute el siguiente comando para descargar el emulador de interfaz de tiempo de ejecución (arquitectura x86-64) de GitHub e instalarlo en su equipo 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 el emulador arm64, reemplace la URL del repositorio de GitHub en el comando anterior por lo siguiente:
```
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 el emulador arm64, reemplace el `$downloadLink` con lo siguiente:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
1. Inicie la imagen de Docker con el comando **docker run**. Tenga en cuenta lo siguiente:
+ `docker-image` es el nombre de la imagen y `test` es la etiqueta.
+ `/main` es el `ENTRYPOINT` de su 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
```
------
Este comando ejecuta la imagen como un contenedor y crea un punto de conexión local en `localhost:9000/2015-03-31/functions/function/invocations`.
**nota**
Si creó la imagen de Docker para la arquitectura del conjunto de instrucciones ARM64, asegúrese de utilizar la opción `--platform linux/arm64` en lugar de `--platform linux/amd64`.
1. Publique un evento en el punto de conexión local.
------
#### [ Linux/macOS ]
En Linux y macOS, ejecute el siguiente comando `curl`:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Este comando invoca la función con un evento vacío y devuelve una respuesta. Si utiliza su propio código de función en lugar del código de función de ejemplo, quizás quiera invocar la función con una carga JSON. Ejemplo:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
En PowerShell, ejecute el siguiente comando `Invoke-WebRequest`:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Este comando invoca la función con un evento vacío y devuelve una respuesta. Si utiliza su propio código de función en lugar del código de función de ejemplo, quizás quiera invocar la función con una carga JSON. Ejemplo:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. Obtenga el ID del contenedor.
```
docker ps
```
1. Use el comando [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) para detener el contenedor. En este comando, reemplace `3766c4ab331c` por el ID del contenedor del paso anterior.
```
docker kill 3766c4ab331c
```
### Implementación de la imagen
**Para cargar la imagen en Amazon ECR y crear la función de Lambda**
1. Para autenticar la CLI de Docker en su registro de Amazon ECR, ejecute el comando [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html).
+ Establezca el valor de `--region` en la Región de AWS en la que desee crear el repositorio de Amazon ECR.
+ Reemplace `111122223333` por el ID de su Cuenta de 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. Cree un repositorio en Amazon ECR con el 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**
El repositorio de Amazon ECR debe estar en la misma Región de AWS que la función de Lambda.
Si se realiza de la forma correcta, verá una respuesta como la siguiente:
```
{
"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 el valor de `repositoryUri` de la salida del paso anterior.
1. Ejecute el comando [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) para etiquetar la imagen local en su repositorio de Amazon ECR como la versión más reciente. En este comando:
+ `docker-image:test` es el nombre y la [etiqueta](https://docs.docker.com/engine/reference/commandline/build/#tag) de su imagen de Docker. Son el nombre y la etiqueta de la imagen que especificó en el comando `docker build`.
+ Reemplace `` por el `repositoryUri` que ha copiado. Asegúrese de incluir `:latest` al final del URI.
```
docker tag docker-image:test :latest
```
Ejemplo:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Ejecute el comando [docker push](https://docs.docker.com/engine/reference/commandline/push/) para implementar la imagen local en el repositorio de Amazon ECR. Asegúrese de incluir `:latest` al final del URI del repositorio.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Cree un rol de ejecución](lambda-intro-execution-role.md#permissions-executionrole-api) para la función si aún no tiene uno. Necesitará el nombre de recurso de Amazon (ARN) del rol en el paso siguiente.
1. Cree la función de Lambda. En `ImageUri`, especifique el URI del repositorio anterior. Asegúrese de incluir `:latest` al final del 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**
Puede crear una función con una imagen de una cuenta AWS diferente, siempre que la imagen esté en la misma región que la función de Lambda. Para obtener más información, consulte [Permisos entre cuentas de Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Invoque la función.
```
aws lambda invoke --function-name hello-world response.json
```
Debería ver una respuesta como la siguiente:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Para ver la salida de la función, compruebe el archivo `response.json`.
Para actualizar el código de la función, debe volver a compilar la imagen, cargar la nueva imagen en el repositorio de Amazon ECR y, a continuación, utilizar el comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) para implementar la imagen en la función de Lambda.
Lambda resuelve la etiqueta de la imagen en un resumen de imagen específico. Esto significa que si apunta la etiqueta de imagen que se utilizó para implementar la función a una nueva imagen en Amazon ECR, Lambda no actualiza automáticamente la función para usar la nueva imagen.
Para implementar la nueva imagen en la misma función de Lambda, debe usar el comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html), incluso si la etiqueta de la imagen en Amazon ECR sigue siendo la misma. En el siguiente ejemplo, la opción `--publish` crea una nueva versión de la función con la imagen del contenedor actualizada.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
# Uso de capas para funciones de Lambda en Go
No recomendamos usar [capas](chapter-layers.md) para administrar las dependencias de las funciones de Lambda escritas en Go. Esto se debe a que las funciones de Lambda en Go se compilan en un único ejecutable, que se proporciona a Lambda al implementar la función. Este ejecutable contiene el código de la función compilada, junto con todas sus dependencias. El uso de capas no solo complica este proceso, sino que también aumenta los tiempos de arranque en frío, ya que las funciones tienen que cargar manualmente los ensamblajes adicionales en la memoria durante la fase de inicialización.
Para usar dependencias externas con los controladores de Go, inclúyalas directamente en el paquete de implementación. Al hacerlo, simplifica el proceso de implementación y también saca partido de las optimizaciones del compilador de Go integrado. Para ver un ejemplo de cómo importar y usar una dependencia como el AWS SDK para Go en su función, consulte [Definición de controladores de funciones de Lambda en Go](golang-handler.md).
# Registro y supervisión de las funciones de Lambda en Go
AWS Lambda supervisa automáticamente funciones de Lambda en su nombre y envía registros a Amazon CloudWatch. Su función de Lambda viene con un grupo de registros de Registros de CloudWatch y con un flujo de registro para cada instancia de su función. El entorno de tiempo de ejecución de Lambda envía detalles sobre cada invocación al flujo de registro y retransmite los registros y otras salidas desde el código de la función. Para obtener más información, consulte [Envío de registros de funciones de Lambda a Registros de CloudWatch](monitoring-cloudwatchlogs.md).
Esta página describe cómo producir resultados de registro a partir del código de la función de Lambda o registros de acceso mediante AWS Command Line Interface, la consola de Lambda o la consola de CloudWatch.
**Topics**
+ [Crear una función que devuelve registros](#golang-logging-output)
+ [Visualización de los registros en la consola de Lambda](#golang-logging-console)
+ [Visualización de los registros de en la consola de CloudWatch](#golang-logging-cwconsole)
+ [Visualización de los registros mediante la AWS Command Line Interface (AWS CLI)](#golang-logging-cli)
+ [Eliminación de registros](#golang-logging-delete)
## Crear una función que devuelve registros
Para generar registros desde el código de la función, puede utilizar los métodos del [paquete fmt](https://golang.org/pkg/fmt/) o cualquier biblioteca de registro que escriba en `stdout` o en `stderr`. En el ejemplo siguiente, se utiliza el [paquete de registro](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**
```
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 de registro**
```
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
```
El tiempo de ejecución de Go registra las líneas `START`, `END` y `REPORT` de cada invocación. La línea del informe proporciona los siguientes detalles.
**Campos de datos de línea REPORT**
+ **RequestId**: el ID de solicitud único para la invocación.
+ **Duración**: la cantidad de tiempo que el método de controlador de función pasó procesando el evento.
+ **Duración facturada**: la cantidad de tiempo facturado por la invocación.
+ **Tamaño de memoria**: la cantidad de memoria asignada a la función.
+ **Máximo de memoria usada**: la cantidad de memoria utilizada por la función. Cuando las invocaciones comparten un entorno de ejecución, Lambda informa de la memoria máxima utilizada en todas las invocaciones. Este comportamiento puede dar como resultado un valor notificado superior al esperado.
+ **Duración de inicio**: para la primera solicitud servida, la cantidad de tiempo que tardó el tiempo de ejecución en cargar la función y ejecutar código fuera del método del controlador.
+ **TraceId de XRAY**: para las solicitudes rastreadas, el [ID de seguimientode AWS X-Ray](services-xray.md).
+ **SegmentId**: para solicitudes rastreadas, el ID del segmento de X-Ray.
+ **Muestras**: para solicitudes rastreadas, el resultado del muestreo.
## Visualización de los registros en la consola de Lambda
Puede utilizar la consola de Lambda para ver la salida del registro después de invocar una función de Lambda.
Si su código se puede probar desde el editor de **código** integrado, encontrará los registros en los **resultados de ejecución**. Cuando utilice la característica de prueba de la consola para invocar una función, encontrará la **Salida de registro** en la sección de **Detalles**.
## Visualización de los registros de en la consola de CloudWatch
Puede utilizar la consola Amazon CloudWatch para ver los registros de todas las invocaciones de funciones de Lambda.
**Visualización de los registros en la consola CloudWatch**
1. En la consola de CloudWatch, abra la [página de grupos de registro](https://console.aws.amazon.com/cloudwatch/home?#logs:).
1. Seleccione el grupo de registros para su función (**/aws/lambda/*your-function-name***).
1. Elija una secuencia de registro.
Cada flujo de registro se corresponde con una [instancia de su función](lambda-runtime-environment.md). Aparece un flujo de registro cuando actualiza la función de Lambda y cuando se crean instancias adicionales para gestionar invocaciones simultáneas. Para encontrar registros para una invocación específica, le recomendamos que interfiera su función con AWS X-Ray. X-Ray registra los detalles sobre la solicitud y el flujo de registro en el seguimiento.
## Visualización de los registros mediante la AWS Command Line Interface (AWS CLI)
La AWS CLI es una herramienta de código abierto que lo habilita para interactuar con los servicios de AWS mediante el uso de comandos en el intérprete de comandos de la línea de comandos. Para completar los pasos de esta sección, debe disponer de la [versión 2 de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
Puede utilizar la [CLI de AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) para recuperar registros de una invocación mediante la opción de comando `--log-type`. La respuesta contiene un campo `LogResult` que contiene hasta 4 KB de registros con codificación base64 a partir de la invocación.
**Example recuperar un ID de registro**
En el ejemplo siguiente se muestra cómo recuperar un *ID de registro* del campo `LogResult` para una función denominada `my-function`.
```
aws lambda invoke --function-name my-function out --log-type Tail
```
Debería ver los siguientes datos de salida:
```
{
"StatusCode": 200,
"LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}
```
**Example decodificar los registros**
En el mismo símbolo del sistema, utilice la utilidad `base64` para decodificar los registros. En el ejemplo siguiente se muestra cómo recuperar registros codificados en base64 para `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
```
La opción **cli-binary-format** es obligatoria si va a utilizar la versión 2 de la AWS CLI. Para que esta sea la configuración predeterminada, ejecute `aws configure set cli-binary-format raw-in-base64-out`. Para obtener más información, consulte [Opciones de la línea de comandos globales compatibles con AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) en la *Guía del usuario de la AWS Command Line Interface versión 2*.
Debería ver los siguientes datos de salida:
```
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
```
La utilidad `base64` está disponible en Linux, macOS y [Ubuntu en Windows](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Es posible que los usuarios de macOS necesiten usar `base64 -D`.
**Example get-logs.sh script**
En el mismo símbolo del sistema, utilice el siguiente script para descargar los últimos cinco eventos de registro. El script utiliza `sed` para eliminar las comillas del archivo de salida y permanece inactivo durante 15 segundos para dar tiempo a que los registros estén disponibles. La salida incluye la respuesta de Lambda y la salida del comando `get-log-events`.
Copie el contenido de la siguiente muestra de código y guárdelo en su directorio de proyecto Lambda como `get-logs.sh`.
La opción **cli-binary-format** es obligatoria si va a utilizar la versión 2 de la AWS CLI. Para que esta sea la configuración predeterminada, ejecute `aws configure set cli-binary-format raw-in-base64-out`. Para obtener más información, consulte [Opciones de la línea de comandos globales compatibles con AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) en la *Guía del usuario de la AWS Command Line Interface versión 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 y Linux (solamente)**
En el mismo símbolo del sistema, es posible que los usuarios de macOS y Linux necesiten ejecutar el siguiente comando para asegurarse de que el script es ejecutable.
```
chmod -R 755 get-logs.sh
```
**Example recuperar los últimos cinco eventos de registro**
En el mismo símbolo del sistema, ejecute el siguiente script para obtener los últimos cinco eventos de registro.
```
./get-logs.sh
```
Debería ver los siguientes datos de salida:
```
{
"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"
}
```
## Eliminación de registros
Los grupos de registro no se eliminan automáticamente cuando se elimina una función. Para evitar almacenar registros indefinidamente, elimine el grupo de registros o [configure un periodo de retención](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention) después de lo cual los registros se eliminan automáticamente.
# Instrumentación del código Go en AWS Lambda
Lambda se integra con AWS X-Ray para permitirle seguir, depurar y optimizar aplicaciones de Lambda. Puede utilizar X-Ray para seguir una solicitud mientras atraviesa los recursos de la aplicación, que pueden incluir funciones de Lambda y otros servicios de AWS.
Para enviar datos de seguimiento a X-Ray, puede utilizar una de estas dos bibliotecas de SDK:
+ [AWS Distro for OpenTelemetry (ADOT)](https://aws.amazon.com/otel): distribución segura, lista para producción y con soporte de AWS del OpenTelemetry (OTel) SDK.
+ [AWS X-Ray SDK for Go](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-go.html): un SDK para generar y enviar datos de seguimiento a X-Ray.
Cada uno de los SDK ofrecen formas de enviar los datos de telemetría al servicio X-Ray. Tras ello, se puede utilizar X-Ray para consultar, filtrar y obtener información sobre las métricas de rendimiento de la aplicación con el fin de identificar problemas y oportunidades de optimización.
**importante**
Los SDK de X-Ray y Powertools para AWS Lambda son parte de una solución de instrumentación completamente integrada que ofrece AWS. Las capas Lambda de ADOT forman parte de un estándar que abarca todo el sector para la instrumentación de seguimiento que recopila más datos en general, pero es posible que no sean adecuadas para todos los casos de uso. Puede implementar el seguimiento integral en X-Ray con cualquiera de las soluciones. Para obtener más información sobre cuál elegir, consulte [Elegir entre SDK de AWS Distro para OpenTelemetry y X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/xray-instrumenting-your-app.html#xray-instrumenting-choosing).
**Topics**
+ [Uso de ADOT para instrumentar las funciones de Go](#golang-adot)
+ [Uso del SDK de X-Ray para instrumentar las funciones de Go](#golang-xray-sdk)
+ [Activación del seguimiento con la consola de Lambda](#golang-tracing-console)
+ [Activación del seguimiento con la API de Lambda](#golang-tracing-api)
+ [Activación del seguimiento con CloudFormation](#golang-tracing-cloudformation)
+ [Interpretación de un seguimiento de X-Ray](#golang-tracing-interpretation)
## Uso de ADOT para instrumentar las funciones de Go
ADOT proporciona [capas](chapter-layers.md) de Lambda completamente administradas que empaquetan todo lo necesario para recopilar datos de telemetría mediante el OTel SDK. Utilizando esta capa, se pueden instrumentar las funciones de Lambda sin tener que modificar el código de ninguna función. También se puede configurar la capa para que realice una inicialización personalizada de OTel. Para obtener más información, consulte [Configuración personalizada del recopilador de ADOT en Lambda](https://aws-otel.github.io/docs/getting-started/lambda#custom-configuration-for-the-adot-collector-on-lambda) en la documentación de ADOT.
Para los tiempos de ejecución de Go, puede agregar la **capa de Lambda administrada por AWS para ADOT Go** a fin de instrumentar de forma automática las funciones. Para obtener instrucciones detalladas sobre cómo agregar esta capa, consulte [Soporte de Lambda de AWS Distro OpenTelemetry para Go](https://aws-otel.github.io/docs/getting-started/lambda/lambda-go) en la documentación de ADOT.
## Uso del SDK de X-Ray para instrumentar las funciones de Go
Si desea registrar detalles sobre las llamadas que realiza la función de Lambda a otros recursos de la aplicación, también puede utilizar el SDK de AWS X-Ray para Go. Para obtener el SDK, descárguelo desde el [repositorio de GitHub](https://github.com/aws/aws-xray-sdk-go) con `go get`:
```
go get github.com/aws/aws-xray-sdk-go
```
Para instrumentar clientes SDK de AWS, pase el cliente al método `xray.AWS()`. Luego puede hacer un seguimiento de las llamadas mediante la versión `WithContext` del método.
```
svc := s3.New(session.New())
xray.AWS(svc.Client)
...
svc.ListBucketsWithContext(ctx aws.Context, input *ListBucketsInput)
```
Una vez agregadas las dependencias correctas y realizados los cambios de código necesarios, active el seguimiento en la configuración de la función mediante la consola de Lambda o la API.
## Activación del seguimiento con la consola de Lambda
Para activar el seguimiento activo de la función Lambda mediante la consola, siga estos pasos:
**Cómo activar el seguimiento activo**
1. Abra la [página de Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija una función.
1. Elija **Configuration** (Configuración), y luego **Monitoring and operations tools** (Herramientas de supervisión y operaciones).
1. En **Herramientas de monitorización adicionales**, elija **Editar**.
1. En **CloudWatch Application Signals y AWS X-Ray**, seleccione **Habilitar** para **Seguimientos de servicios de Lambda**.
1. Seleccione **Save**.
## Activación del seguimiento con la API de Lambda
Configure el rastreo en la función Lambda con AWS CLI o SDK de AWS, utilice las siguientes operaciones 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)
El siguiente comando de ejemplo de la AWS CLI habilita el seguimiento activo en una función llamada **my-function**.
```
aws lambda update-function-configuration --function-name my-function \
--tracing-config Mode=Active
```
El modo de seguimiento forma parte de la configuración específica de la versión, cuando se publica una versión de la función. No se puede cambiar el modo de seguimiento de una versión publicada.
## Activación del seguimiento con CloudFormation
Para activar el seguimiento en un recurso de `AWS::Lambda::Function` de una plantilla de CloudFormation, utilice la propiedad `TracingConfig`.
**Example [función-inline.yml](https://github.com/awsdocs/aws-lambda-developer-guide/blob/master/templates/function-inline.yml): configuración de rastreo**
```
Resources:
function:
Type: [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
Properties:
TracingConfig:
Mode: Active
...
```
Para un recurso AWS Serverless Application Model de AWS SAM (`AWS::Serverless::Function`) , utilice la propiedad `Tracing`.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/template.yml): configuración de rastreo**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
Tracing: Active
...
```
## Interpretación de un seguimiento de X-Ray
La función necesita permiso para cargar datos de rastreo en X-Ray. Cuando activa el rastreo activo en la consola de Lambda, Lambda agrega los permisos necesarios al [rol de ejecución](lambda-intro-execution-role.md) de la función. De lo contrario, agregue la política [AWSXRayDaemonWriteAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess) al rol de ejecución.
Después de configurar el seguimiento activo, se pueden observar solicitudes específicas a través de la aplicación. El [gráfico de servicios de X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html#xray-concepts-servicegraph) muestra información sobre la aplicación y todos sus componentes. En el siguiente ejemplo, se muestra una aplicación con dos funciones. La función principal procesa eventos y, a veces, devuelve errores. La segunda función de la cadena procesa los errores que aparecen en el primer grupo de registros y utiliza el SDK de AWS para llamar a X-Ray, Amazon Simple Storage Service (Amazon S3) y Registros de Amazon CloudWatch.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/sample-errorprocessor-servicemap.png)
X-Ray no sigue todas las solicitudes realizadas a la aplicación. X-Ray aplica un algoritmo de muestreo para garantizar que el seguimiento sea eficiente, a la vez que proporciona una muestra representativa de todas las solicitudes. La tasa de muestreo es 1 solicitud por segundo y un 5 por ciento de las solicitudes adicionales. La frecuencia de muestreo de X-Ray no se puede configurar para las funciones.
En X-Ray, un *seguimiento* registra información sobre una solicitud procesada por uno o varios *servicios*. Lambda registra 2 segmentos por seguimiento, lo que crea dos nodos en el gráfico de servicios. La siguiente imagen resalta estos dos nodos:
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/xray-servicemap-function.png)
El primer nodo, situado a la izquierda, representa el servicio de Lambda, que recibe la solicitud de invocación. El segundo nodo representa la función Lambda específica. En el siguiente ejemplo, se muestra un seguimiento con estos dos segmentos. Ambos se denominan **my-function**, pero uno tiene un origen de `AWS::Lambda` y el otro tiene origen de `AWS::Lambda::Function`. Si el segmento `AWS::Lambda` muestra un error, el servicio Lambda tuvo un problema. Si el segmento `AWS::Lambda::Function` muestra un error, la función tuvo un problema.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)
En este ejemplo, el segmento `AWS::Lambda::Function` aparece ampliado para mostrar los tres subsegmentos.
**nota**
AWS está implementando cambios en el servicio Lambda. Debido a estos cambios, es posible que vea pequeñas diferencias entre la estructura y el contenido de los mensajes de registro del sistema y los segmentos de rastro emitidos por diferentes funciones de Lambda en su Cuenta de AWS.
El rastro de ejemplo que se muestra aquí ilustra el segmento de función de estilo antiguo. Las diferencias entre los segmentos de estilo antiguo y nuevo se describen en los párrafos siguientes.
Estos cambios se implementarán en las próximas semanas y todas las funciones de todas las Regiones de AWS, excepto en las regiones de China y GovCloud, pasarán a utilizar el nuevo formato de mensajes de registro y segmentos de rastro.
El segmento de función de estilo antiguo contiene los siguientes subsegmentos:
+ **Inicialización**: representa el tiempo dedicado a cargar la función y ejecutar el [código de inicialización](foundation-progmodel.md). Este subsegmento aparece únicamente para el primer evento que procesa cada instancia de la función.
+ **Invocación**: representa el tiempo dedicado a ejecutar el código del controlador.
+ **Sobrecarga**: representa el tiempo que el tiempo de ejecución de Lambda dedica a prepararse para gestionar el siguiente evento.
El segmento de función de estilo nuevo no contiene ningún subsegmento de `Invocation`. En cambio, los subsegmentos de clientes se adjuntan directamente al segmento de la función. Para obtener más información sobre la estructura de los segmentos de funciones de estilo antiguo y nuevo, consulte [Comprensión de los rastros](services-xray.md#services-xray-traces).
También puede instrumentar clientes HTTP, registrar consultas SQL y crear subsegmentos personalizados con anotaciones y metadatos. Para obtener más información, consulte el [SDK de AWS X-Ray para Go](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html) en la *Guía para desarrolladores de AWS X-Ray*.
**Precios**
Puede utilizar el seguimiento de X-Ray de manera gratuita cada mes hasta un límite determinado como parte del nivel Gratuito de AWS. A partir de ese umbral, X-Ray realiza cargos por almacenamiento y recuperación del seguimiento. Para obtener más información, consulte [Precios de AWS X-Ray](https://aws.amazon.com/xray/pricing/).