# Habilitación de sus aplicaciones en Lambda
<a name="CloudWatch-Application-Signals-Enable-LambdaMain"></a>

Puede habilitar Application Signals para las funciones de Lambda. Application Signals instrumenta de forma automática sus funciones de Lambda mediante las bibliotecas ⁣mejoradas de AWS Distro para OpenTelemetry (ADOT), que se proporcionan a través de una capa de Lambda. Esta capa de AWS Lambda para OpenTelemetry empaqueta e implementa las bibliotecas necesarias para la instrumentación automática de Application Signals.

Además de admitir Application Signals, esta capa de Lambda también es un componente de la compatibilidad de Lambda con OpenTelemetry y proporciona funcionalidad de seguimiento.

También puede mejorar la observabilidad de Lambda mediante Transaction Search, que permite capturar las unidades de seguimiento de los seguimientos para la invocación de funciones de Lambda sin muestreo. Esta característica le permite recopilar las unidades de seguimiento de las funciones, sin que se vea afectado por la marca `sampled` en la propagación del contexto de seguimiento. Esto garantiza que no haya ningún impacto adicional en los servicios dependientes de las fases posteriores. Al habilitar Transaction Search en Lambda, obtiene una visibilidad completa del rendimiento de las funciones y puede solucionar problemas poco frecuentes. Para empezar, consulte [Transaction Search](CloudWatch-Transaction-Search.md)

**Topics**
+ [Introducción](#Application-Signals-Enable-Lambda-Methods-Getting-Started)
+ [Uso de la consola de CloudWatch Application Signals](#Enable-Lambda-CWConsole)
+ [Utilice la consola de Lambda](#Enable-Lambda-LambdaConsole)
+ [Habilitación de Application Signals en Lambda con el AWS CDK](#CloudWatch-Application-Signals-Lambda-CDK)
+ [Activación de Application Signals en Lambda con el protocolo de contexto para modelos (MCP)](#CloudWatch-Application-Signals-Lambda-MCP)
+ [(Opcional) Supervisión del estado de su aplicación](#CloudWatch-Application-Signals-Monitor-Lambda)
+ [Habilitación manual de Application Signals](#Enable-Lambda-Manually)
+ [Deshabilitación manual de Application Signals](#Disable-Lambda-Manually)
+ [Configuración de Application Signals](#Configuring-Lambda-AppSignals)
+ [ARN de la capa de AWS Lambda para OpenTelemetry](#Enable-Lambda-Layers)
+ [Implementación de las funciones de Lambda mediante el contenedor de Amazon ECR](#containerized-lambda)

## Introducción
<a name="Application-Signals-Enable-Lambda-Methods-Getting-Started"></a>

Existen tres métodos para habilitar Application Signals para las funciones de Lambda.

Tras habilitar Application Signals para una función de Lambda, la telemetría de esa función tarda unos minutos en aparecer en la consola de Application Signals. 
+ Uso de la consola de CloudWatch Application Signals
+ Utilice la consola de Lambda
+ Agregue de forma manual la capa de AWS Lambda para OpenTelemetry al tiempo de ejecución de su función de Lambda.

Cada uno de estos métodos agrega una capa de AWS Lambda para OpenTelemetry a la función.

## Uso de la consola de CloudWatch Application Signals
<a name="Enable-Lambda-CWConsole"></a>

Siga estos pasos para utilizar la consola de Application Signals para habilitar Application Signals para una función de Lambda.

1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. En el panel de navegación de servicio, elija **Application Signals**, **Servicios**.

1. En el área de la lista **Servicios**, seleccione **Habilitar señales de aplicaciones**.

1. Elija el mosaico **Lambda**.

1. Seleccione cada función que quiera habilitar para Application Signals y, a continuación, elija **Listo**.

## Utilice la consola de Lambda
<a name="Enable-Lambda-LambdaConsole"></a>

Siga estos pasos para utilizar la consola de Lambda para habilitar Application Signals para una función de Lambda.

1. Abra la consola de AWS Lambda en [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1. En el panel de navegación, elija **Funciones** y, a continuación, elija el nombre de la función de que quiera habilitar.

1. Elija la pestaña **Configuración**, y luego **Herramientas de monitoreo y operaciones**.

1. Elija **Edit (Edición de)**.

1. En la sección **CloudWatch Application Signals y X-Ray**, seleccione **Recopilar automáticamente seguimientos de aplicaciones y métricas de aplicaciones estándar con Application Signals** y **Recopilar automáticamente seguimientos del servicio Lambda para obtener visibilidad integral con X-Ray**.

1. Seleccione **Save**.

## Habilitación de Application Signals en Lambda con el AWS CDK
<a name="CloudWatch-Application-Signals-Lambda-CDK"></a>

 Si aún no ha activado Application Signals en esta cuenta, debe conceder a Application Signals los permisos que necesita para detectar los servicios. Para obtener más información, consulte [Habilitación de Application Signals en su cuenta](CloudWatch-Application-Signals-Enable.md).

1. Habilite Application Signals para sus aplicaciones

   ```
   import { aws_applicationsignals as applicationsignals } from 'aws-cdk-lib';
   
   const cfnDiscovery = new applicationsignals.CfnDiscovery(this,
     'ApplicationSignalsServiceRole', { }
   );
   ```

   El recurso Discovery de CloudFormation otorga a Application Signals los siguientes permisos:
   + `xray:GetServiceGraph`
   + `logs:StartQuery`
   + `logs:GetQueryResults`
   + `cloudwatch:GetMetricData`
   + `cloudwatch:ListMetrics`
   + `tag:GetResources`

   Para obtener más información acerca de este rol, consulte [Permisos de roles vinculados a un servicio para CloudWatch Application Signals](using-service-linked-roles.md#service-linked-role-signals).

1. Agregue la política de IAM `CloudWatchLambdaApplicationSignalsExecutionRolePolicy` a la función de Lambda.

   ```
   const fn = new Function(this, 'DemoFunction', {
       code: Code.fromAsset('$YOUR_LAMBDA.zip'),
       runtime: Runtime.PYTHON_3_12,
       handler: '$YOUR_HANDLER'
   })
   
   fn.role?.addManagedPolicy(ManagedPolicy.fromAwsManagedPolicyName('CloudWatchLambdaApplicationSignalsExecutionRolePolicy'));
   ```

1. Sustituya `$AWS_LAMBDA_LAYER_FOR_OTEL_ARN` por el [ARN real de la capa de AWS Lambda para OpenTelemetry](https://aws-otel.github.io/docs/getting-started/lambda#adot-lambda-layer-arns) de la región.

   ```
   fn.addLayers(LayerVersion.fromLayerVersionArn(
       this, 'AwsLambdaLayerForOtel',
       '$AWS_LAMBDA_LAYER_FOR_OTEL_ARN'
   ))
   fn.addEnvironment("AWS_LAMBDA_EXEC_WRAPPER", "/opt/otel-instrument");
   ```

## Activación de Application Signals en Lambda con el protocolo de contexto para modelos (MCP)
<a name="CloudWatch-Application-Signals-Lambda-MCP"></a>

Puede usar el servidor Protocolo de contexto para modelos (MCP) de CloudWatch Application Signals para activar Application Signals en funciones de Lambda mediante interacciones de IA conversacional. Proporciona una interfaz de lenguaje natural para configurar la supervisión de Application Signals.

El servidor MCP automatiza el proceso de activación al comprender sus requisitos y generar la configuración adecuada. En lugar de seguir manualmente los pasos de la consola o escribir el código del CDK, simplemente puede describir lo que desea activar.

### Requisitos previos
<a name="CloudWatch-Application-Signals-Lambda-MCP-Prerequisites"></a>

Antes de usar el servidor MCP para activar Application Signals, asegúrese de lo siguiente:
+ Entorno de desarrollo compatible con MCP (como Kiro, Claude Desktop, VSCode con extensiones MCP u otras herramientas compatibles con MCP)
+ El servidor MCP de CloudWatch Application Signals configurado en el IDE. Para obtener instrucciones de configuración detalladas, consulte la [documentación del servidor MCP de CloudWatch Application Signals](https://awslabs.github.io/mcp/servers/cloudwatch-applicationsignals-mcp-server).

### Uso del servidor MCP
<a name="CloudWatch-Application-Signals-Lambda-MCP-Usage"></a>

Una vez que haya configurado el servidor MCP de CloudWatch Application Signals en el IDE, puede solicitar una guía de activación mediante instrucciones en lenguaje natural. Si bien el asistente de codificación puede inferir el contexto a partir de la estructura del proyecto, proporcionar detalles específicos en las instrucciones ayuda a garantizar una orientación más precisa y pertinente. Incluya información como el lenguaje de programación de la función de Lambda, el nombre de la función y las rutas absolutas al código de la función de Lambda y al código de la infraestructura.

**Peticiones de prácticas recomendadas (específicas y completas):**

```
"Enable Application Signals for my Python Lambda function.
My function code is in /home/user/order-processor/lambda and IaC is in /home/user/order-processor/terraform"

"I want to add observability to my Node.js Lambda function 'checkout-handler'.
The function code is at /Users/dev/checkout-function and
the CDK infrastructure is at /Users/dev/checkout-function/cdk"

"Help me instrument my Java Lambda function with Application Signals.
Function directory: /opt/apps/payment-lambda
CDK infrastructure: /opt/apps/payment-lambda/cdk"
```

**Peticiones menos efectivas:**

```
"Enable monitoring for my Lambda"
→ Missing: language, paths

"Enable Application Signals. My code is in ./src and IaC is in ./infrastructure"
→ Problem: Relative paths instead of absolute paths

"Enable Application Signals for my Lambda at /home/user/myfunction"
→ Missing: programming language
```

**Plantilla rápida:**

```
"Enable Application Signals for my [LANGUAGE] Lambda function.
Function code: [ABSOLUTE_PATH_TO_FUNCTION]
IaC code: [ABSOLUTE_PATH_TO_IAC]"
```

### Beneficios de usar el servidor MCP
<a name="CloudWatch-Application-Signals-Lambda-MCP-Benefits"></a>

El uso del servidor MCP de CloudWatch Application Signals ofrece varias ventajas:
+ **Interfaz en lenguaje natural:** describa lo que desea activar sin memorizar comandos ni sintaxis de la configuración.
+ **Guía adaptada al contexto:** el servidor MCP comprende el entorno específico y proporciona recomendaciones personalizadas
+ **Reducción de errores:** la generación automática de configuraciones minimiza los errores de escritura manual.
+ **Configuración más rápida:** cambie de la intención a la implementación con mayor rapidez.
+ **Herramienta de aprendizaje:** vea las configuraciones generadas y comprenda cómo funciona Application Signals.

Para obtener más información sobre la configuración y el uso del servidor MCP de CloudWatch Application Signals, consulte la [documentación del servidor MCP](https://awslabs.github.io/mcp/servers/cloudwatch-applicationsignals-mcp-server).

## (Opcional) Supervisión del estado de su aplicación
<a name="CloudWatch-Application-Signals-Monitor-Lambda"></a>

Una vez que haya habilitado sus aplicaciones en Lambda, podrá supervisar el estado de las mismas. Para obtener más información, consulte [Monitoreo del estado operativo de sus aplicaciones con Application Signals](Services.md).

## Habilitación manual de Application Signals
<a name="Enable-Lambda-Manually"></a>

Siga estos pasos para habilitar de manera manual Application Signals para una función de Lambda.

1. Agregue la capa de AWS Lambda para OpenTelemetry al tiempo de ejecución de Lambda. Para encontrar el ARN de capa de la región, consulte [ADOT Lambda Layer ARNs](https://aws-otel.github.io/docs/getting-started/lambda#adot-lambda-layer-arns).

1. Agregue la variable de entorno `AWS_LAMBDA_EXEC_WRAPPER=/opt/otel-instrument`.

   Agregue la variable de entorno `LAMBDA_APPLICATION_SIGNALS_REMOTE_ENVIRONMENT` para configurar entornos de Lambda personalizados. Los entornos lambda están configurados en `lambda:default` de forma predeterminada.

1. Conecte la política de IAM administrada por AWS **CloudWatchLambdaApplicationSignalsExecutionRolePolicy** al rol de ejecución de Lambda.

1. (Opcional) Se recomienda habilitar el seguimiento activo de Lambda para obtener una mejor experiencia de seguimiento. Para obtener más información, consulte [Visualización de las invocaciones de la función de Lambda mediante AWS X-Ray](https://docs.aws.amazon.com/lambda/latest/dg/services-xray.html).

## Deshabilitación manual de Application Signals
<a name="Disable-Lambda-Manually"></a>

Para deshabilitar de forma manual Application Signals para una función de Lambda, quite la capa de AWS Lambda para OpenTelemetry del tiempo de ejecución de Lambda y quite la variable de entorno `AWS_LAMBDA_EXEC_WRAPPER=/opt/otel-instrument`.

## Configuración de Application Signals
<a name="Configuring-Lambda-AppSignals"></a>

Puede usar esta sección para configurar Application Signals en Lambda.

 **Agrupación de varias funciones de Lambda en un solo servicio** 

La variable del entorno `OTEL_SERVICE_NAME` establece el nombre del servicio. Esto se mostrará como el nombre del servicio de la aplicación en los paneles de Application Signals. Puede asignar el mismo nombre de servicio a varias funciones de Lambda y se fusionarán en un solo servicio en Application Signals. Si no proporciona ningún valor para esta clave, se utiliza el nombre predeterminado de la función de Lambda.

 **Muestreo** 

Por defecto, la estrategia de muestreo de rastros se basa en la principal. Puede ajustar la estrategia de muestreo configurando variables de entorno en `OTEL_TRACES_SAMPLER`.

Por ejemplo, establezca la tasa de muestreo de rastros en un 30 %.

```
OTEL_TRACES_SAMPLER=traceidratio
OTEL_TRACES_SAMPLER_ARG=0.3
```

Para obtener más información, consulte [OpenTelemetry Environment Variable Specification](https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/).

 **Habilitación de toda la instrumentación de la biblioteca** 

Para reducir los inicios en frío de Lambda, de forma predeterminada, solo la instrumentación del AWS SDK y HTTP está habilitada para Python, Node y Java. Puede establecer variables de entorno para habilitar la instrumentación de otras bibliotecas utilizadas en su función de Lambda.
+ Python – `OTEL_PYTHON_DISABLED_INSTRUMENTATIONS=none`
+ Nodo: `OTEL_NODE_DISABLED_INSTRUMENTATIONS=none`
+ Java – `OTEL_INSTRUMENTATION_COMMON_DEFAULT_ENABLED=true`

## ARN de la capa de AWS Lambda para OpenTelemetry
<a name="Enable-Lambda-Layers"></a>

Para obtener la lista completa de los ARN de capa de AWS Lambda para OpenTelemetry por región y tiempo de ejecución, consulte [ADOT Lambda Layer ARNs](https://aws-otel.github.io/docs/getting-started/lambda#adot-lambda-layer-arns) en la documentación de AWS Distro para OpenTelemetry. La capa está disponible para tiempos de ejecución de Python, Node.js, .NET y Java.

## Implementación de las funciones de Lambda mediante el contenedor de Amazon ECR
<a name="containerized-lambda"></a>

Las funciones de Lambda implementadas como imágenes de contenedor no admiten las capas Lambda de la manera tradicional. Al utilizar imágenes de contenedor, no puede adjuntar una capa como lo haría con otros métodos de implementación de Lambda. En su lugar, debe incorporar de forma manual el contenido de la capa a la imagen del contenedor durante el proceso de compilación.

------
#### [ Java ]

Puede aprender a integrar la capa de AWS Lambda para OpenTelemetry en su función de Lambda de Java en contenedores, descargar el artefacto `layer.zip` e integrarlo en su contenedor de función de Lambda de Java para habilitar la supervisión de Application Signals.

**Requisitos previos**
+ AWS CLI configurada con sus credenciales
+ Docker instalado
+ Estas instrucciones asumen que está en una plataforma x86\$164

1. **Configure la estructura del proyecto**

   Cree un directorio para la función de Lambda

   ```
   mkdir java-appsignals-container-lambda && \
   cd java-appsignals-container-lambda
   ```

   Cree una estructura de proyecto de Maven

   ```
   mkdir -p src/main/java/com/example/java/lambda
   mkdir -p src/main/resources
   ```

1. **Cree un archivo Dockerfile**

   Descargue e integre la capa de OpenTelemetry con soporte para Application Signals directamente en la imagen de contenedor de Lambda. Para ello, se crea el archivo `Dockerfile`.

   ```
   FROM public.ecr.aws/lambda/java:21
   
   # Install utilities
   RUN dnf install -y unzip wget maven
   
   # Download the OpenTelemetry Layer with AppSignals Support
   RUN wget https://github.com/aws-observability/aws-otel-java-instrumentation/releases/latest/download/layer.zip -O /tmp/layer.zip
   
   # Extract and include Lambda layer contents
   RUN mkdir -p /opt && \
       unzip /tmp/layer.zip -d /opt/ && \
       chmod -R 755 /opt/ && \
       rm /tmp/layer.zip
   
   # Copy and build function code
   COPY pom.xml ${LAMBDA_TASK_ROOT}
   COPY src ${LAMBDA_TASK_ROOT}/src
   RUN mvn clean package -DskipTests
   
   # Copy the JAR file to the Lambda runtime directory (from inside the container)
   RUN mkdir -p ${LAMBDA_TASK_ROOT}/lib/
   RUN cp ${LAMBDA_TASK_ROOT}/target/function.jar ${LAMBDA_TASK_ROOT}/lib/
   
   # Set the handler
   CMD ["com.example.java.lambda.App::handleRequest"]
   ```
**nota**  
El archivo `layer.zip` contiene la instrumentación de OpenTelemetry necesaria para que el soporte de AWS Application Signals pueda supervisar su función de Lambda.  
Los pasos de extracción de la capa garantizan lo siguiente:  
El contenido del archivo layer.zip se extrae correctamente en el `/opt/ directory`
El script `otel-instrument` recibe los permisos de ejecución adecuados
El archivo temporal layer.zip se elimina para reducir el tamaño de la imagen

1. **Código de la función de Lambda**: cree un archivo Java para su controlador de Lambda en `src/main/java/com/example/lambda/App.java:`

   Su proyecto debe tener un aspecto similar al siguiente:

   ```
   .
   ├── Dockerfile
   ├── pom.xml
   └── src
       └── main
           ├── java
           │   └── com
           │       └── example
           │           └── java
           │               └── lambda
           │                   └── App.java
           └── resources
   ```

1. **Cree e implemente la imagen de contenedor**

   **Configure las variables de entorno**

   ```
   AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
   AWS_REGION=$(aws configure get region)
   
   # For fish shell users:
   # set AWS_ACCOUNT_ID (aws sts get-caller-identity --query Account --output text)
   # set AWS_REGION (aws configure get region)
   ```

   **Autentique con el ECR** 

   Primero con el ECR público (para la imagen base):

   ```
   aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws
   ```

   Luego, con su ECR privado:

   ```
   aws ecr get-login-password --region $AWS_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com
   ```

   **Cree, etiquete y envíe imágenes**

   ```
   # Build the Docker image
   docker build -t lambda-appsignals-demo .
   
   # Tag the image
   docker tag lambda-appsignals-demo:latest $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest
   
   # Push the image
   docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest
   ```

1. **Cree y configure la función de Lambda**

   Cree una nueva función con la consola de Lambda.

   Seleccione **Imagen del contenedor** como opción de implementación.

   Elija **Examinar imágenes** para seleccionar su imagen de Amazon ECR.

1. **Pruebas y verificaciones: pruebe su Lambda con un evento simple. Si la integración de la capa se realiza correctamente, su Lambda aparecerá en el mapa de servicios de Application Signals.**

   Verá rastros y métricas de su función de Lambda en la consola de CloudWatch.

**Solución de problemas**

Si Application Signals no funciona, compruebe lo siguiente:
+ Compruebe los registros de la función para ver si hay algún error relacionado con la instrumentación de OpenTelemetry
+ Verifique si la variable de entorno `AWS_LAMBDA_EXEC_WRAPPER` está configurada correctamente
+ Asegúrese de que la extracción de la capa en el archivo de Docker se haya completado correctamente
+ Confirme si los permisos de IAM están correctamente asociados
+ Si es necesario, aumente los valores de *Tiempo de espera y memoria* en la configuración general de la función de Lambda

------
#### [ .Net ]

Puede aprender a integrar la capa de OpenTelemetry compatible con Application Signals en su función de Lambda de .Net en contenedores, descargar el artefacto `layer.zip` e integrarlo en su función de Lambda de .Net para habilitar la supervisión de Application Signals.

**Requisitos previos**
+ AWS CLI configurada con sus credenciales
+ Docker instalado
+ SDK para .NET 8
+ Estas instrucciones asumen que está en una plataforma x86\$164

1. **Configure la estructura del proyecto**

   Cree un directorio para la imagen del contenedor de su función de Lambda

   ```
   mkdir dotnet-appsignals-container-lambda && \
   cd dotnet-appsignals-container-lambda
   ```

1. **Cree un archivo Dockerfile**

   Descargue e integre la capa de OpenTelemetry con soporte para Application Signals directamente en la imagen de contenedor de Lambda. Para ello, se crea el archivo `Dockerfile`.

   ```
   FROM public.ecr.aws/lambda/dotnet:8
   
   # Install utilities
   RUN dnf install -y unzip wget dotnet-sdk-8.0 which
   
   # Add dotnet command to docker container's PATH
   ENV PATH="/usr/lib64/dotnet:${PATH}"
   
   # Download the OpenTelemetry Layer with AppSignals Support
   RUN wget https://github.com/aws-observability/aws-otel-dotnet-instrumentation/releases/latest/download/layer.zip -O /tmp/layer.zip
   
   # Extract and include Lambda layer contents
   RUN mkdir -p /opt && \
       unzip /tmp/layer.zip -d /opt/ && \
       chmod -R 755 /opt/ && \
       rm /tmp/layer.zip
   
   WORKDIR ${LAMBDA_TASK_ROOT}
   
   # Copy the project files
   COPY dotnet-lambda-function/src/dotnet-lambda-function/*.csproj ${LAMBDA_TASK_ROOT}/
   COPY dotnet-lambda-function/src/dotnet-lambda-function/Function.cs ${LAMBDA_TASK_ROOT}/
   COPY dotnet-lambda-function/src/dotnet-lambda-function/aws-lambda-tools-defaults.json ${LAMBDA_TASK_ROOT}/
   
   # Install dependencies and build the application
   RUN dotnet restore
   
   # Use specific runtime identifier and disable ReadyToRun optimization
   RUN dotnet publish -c Release -o out --self-contained false /p:PublishReadyToRun=false
   
   # Copy the published files to the Lambda runtime directory
   RUN cp -r out/* ${LAMBDA_TASK_ROOT}/
   
   CMD ["dotnet-lambda-function::dotnet_lambda_function.Function::FunctionHandler"]
   ```
**nota**  
El archivo `layer.zip` contiene la instrumentación de OpenTelemetry necesaria para que el soporte de AWS Application Signals pueda supervisar su función de Lambda.  
Los pasos de extracción de la capa garantizan lo siguiente:  
El contenido del archivo layer.zip se extrae correctamente en el `/opt/ directory`
El script `otel-instrument` recibe los permisos de ejecución adecuados
El archivo temporal layer.zip se elimina para reducir el tamaño de la imagen

1. **Código de función de Lambda**: inicialice su proyecto Lambda mediante la plantilla AWS Lambda .NET:

   ```
   # Install the Lambda templates if you haven't already
   dotnet new -i Amazon.Lambda.Templates
   
   # Create a new Lambda project
   dotnet new lambda.EmptyFunction -n dotnet-lambda-function
   ```

   Su proyecto debe tener un aspecto similar al siguiente:

   ```
   .
   ├── Dockerfile
   └── dotnet-lambda-function
       ├── src
       │   └── dotnet-lambda-function
       │       ├── Function.cs
       │       ├── Readme.md
       │       ├── aws-lambda-tools-defaults.json
       │       └── dotnet-lambda-function.csproj
       └── test
           └── dotnet-lambda-function.Tests
               ├── FunctionTest.cs
               └── dotnet-lambda-function.Tests.csproj
   ```

1. **Cree e implemente la imagen de contenedor**

   **Configure las variables de entorno**

   ```
   AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
   AWS_REGION=$(aws configure get region)
   
   # For fish shell users:
   # set AWS_ACCOUNT_ID (aws sts get-caller-identity --query Account --output text)
   # set AWS_REGION (aws configure get region)
   ```

   Actualice el código `Function.cs` para:

   Actualice el código `dotnet-lambda-function.csproj` para:

   ```
   <Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
       <TargetFramework>net8.0>/TargetFramework>
      <ImplicitUsings>enable</ImplicitUsings>
       <Nullable>enable</Nullable>
       <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
       <AWSProjectType>Lambda</AWSProjectType>
       
       <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
       
       <PublishReadyToRun>true</PublishReadyToRun>
    </PropertyGroup>
     <ItemGroup>
       <PackageReference Include="Amazon.Lambda.Core" Version="2.5.0" />
       <PackageReference Include="Amazon.Lambda.Serialization.SystemTextJson" Version="2.4.4" />
       <PackageReference Include="AWSSDK.S3" Version="3.7.305.23" />
     </ItemGroup>
   </Project>
   ```

1. **Cree e implemente la imagen de contenedor**

   Configure las variables de entorno

   ```
   AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
   AWS_REGION=$(aws configure get region)
   
   # For fish shell users:
   # set AWS_ACCOUNT_ID (aws sts get-caller-identity --query Account --output text)
   # set AWS_REGION (aws configure get region)
   ```

   Autenticarse con Amazon ECR público

   ```
   aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws
   ```

   Autenticarse con Amazon ECR privado

   ```
   aws ecr get-login-password --region $AWS_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com
   ```

   Cree un repositorio de Amazon ECR (si es necesario)

   ```
   aws ecr create-repository \
       --repository-name lambda-appsignals-demo \
       --region $AWS_REGION
   ```

   Cree, etiquete y envíe imágenes de Docker

   ```
   # Build the Docker image
   docker build -t lambda-appsignals-demo .
   
   # Tag the image
   docker tag lambda-appsignals-demo:latest $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest
   
   # Push the image
   docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest
   
   5. Create and Configure the Lambda Function
   ```

1. **Cree y configure la función de Lambda**

   Cree una nueva función con la consola de Lambda.

   Seleccione **Imagen del contenedor** como opción de implementación.

   Elija **Examinar imágenes** para seleccionar su imagen de Amazon ECR.

1. **Pruebas y verificaciones: pruebe su Lambda con un evento simple. Si la integración de la capa se realiza correctamente, su Lambda aparecerá en el mapa de servicios de Application Signals.**

   Verá rastros y métricas de su función de Lambda en la consola de CloudWatch.

**Solución de problemas**

Si Application Signals no funciona, compruebe lo siguiente:
+ Compruebe los registros de la función para ver si hay algún error relacionado con la instrumentación de OpenTelemetry
+ Verifique si la variable de entorno `AWS_LAMBDA_EXEC_WRAPPER` está configurada correctamente
+ Asegúrese de que la extracción de la capa en el archivo de Docker se haya completado correctamente
+ Confirme si los permisos de IAM están correctamente asociados
+ Si es necesario, aumente los valores de *Tiempo de espera y memoria* en la configuración general de la función de Lambda

------
#### [ Node.js ]

Puede aprender a integrar la capa de OpenTelemetry compatible con Application Signals en su función de Lambda de Node.js en contenedores, descargar el artefacto `layer.zip` e integrarlo en su función Lambda de Node.js para habilitar la supervisión de Application Signals.

**Requisitos previos**
+ AWS CLI configurada con sus credenciales
+ Docker instalado
+ Estas instrucciones asumen que está en una plataforma x86\$164

1. **Configure la estructura del proyecto**

   Cree un directorio para la imagen del contenedor de su función de Lambda

   ```
   mkdir nodejs-appsignals-container-lambda &&\
   cd nodejs-appsignals-container-lambda
   ```

1. **Cree un archivo Dockerfile**

   Descargue e integre la capa de OpenTelemetry con soporte para Application Signals directamente en la imagen de contenedor de Lambda. Para ello, se crea el archivo `Dockerfile`.

   ```
   # Dockerfile
   FROM public.ecr.aws/lambda/nodejs:22
   
   # Install utilities
   RUN dnf install -y unzip wget
   
   # Download the OpenTelemetry Layer with AppSignals Support
   RUN wget https://github.com/aws-observability/aws-otel-js-instrumentation/releases/latest/download/layer.zip -O /tmp/layer.zip
   
   # Extract and include Lambda layer contents
   RUN mkdir -p /opt && \
       unzip /tmp/layer.zip -d /opt/ && \
       chmod -R 755 /opt/ && \
       rm /tmp/layer.zip
   
   # Install npm dependencies
   RUN npm init -y
   RUN npm install
   
   # Copy function code
   COPY *.js ${LAMBDA_TASK_ROOT}/
   
   # Set the CMD to your handler
   CMD [ "index.handler" ]
   ```
**nota**  
El archivo `layer.zip` contiene la instrumentación de OpenTelemetry necesaria para que el soporte de AWS Application Signals pueda supervisar su función de Lambda.  
Los pasos de extracción de la capa garantizan lo siguiente:  
El contenido del archivo layer.zip se extrae correctamente en el `/opt/ directory`
El script `otel-instrument` recibe los permisos de ejecución adecuados
El archivo temporal layer.zip se elimina para reducir el tamaño de la imagen

1. **Código de la función de Lambda**

   Cree un archivo `index.js`, con el siguiente contenido:

   ```
   const { S3Client, ListBucketsCommand } = require('@aws-sdk/client-s3');
   
   // Initialize S3 client
   const s3Client = new S3Client({ region: process.env.AWS_REGION });
   
   exports.handler = async function(event, context) {
     console.log('Received event:', JSON.stringify(event, null, 2));
     console.log('Handler initializing:', exports.handler.name);
   
     const response = {
       statusCode: 200,
       body: {}
     };
   
     try {
       // List S3 buckets
       const command = new ListBucketsCommand({});
       const data = await s3Client.send(command);
   
       // Extract bucket names
       const bucketNames = data.Buckets.map(bucket => bucket.Name);
   
       response.body = {
         message: 'Successfully retrieved buckets',
         buckets: bucketNames
       };
   
     } catch (error) {
       console.error('Error listing buckets:', error);
   
       response.statusCode = 500;
       response.body = {
         message: `Error listing buckets: ${error.message}`
       };
     }
   
     return response;
   };
   ```

   La estructura de su proyecto debería tener un aspecto similar a este:

   ```
   .
   ├── Dockerfile
   └── index.js
   ```

1. **Cree e implemente la imagen de contenedor**

   **Configure las variables de entorno**

   ```
   AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
   AWS_REGION=$(aws configure get region)
   
   # For fish shell users:
   # set AWS_ACCOUNT_ID (aws sts get-caller-identity --query Account --output text)
   # set AWS_REGION (aws configure get region)
   ```

   Autenticarse con Amazon ECR público

   ```
   aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws
   ```

   Autenticarse con Amazon ECR privado

   ```
   aws ecr get-login-password --region $AWS_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com
   ```

   Cree un repositorio de Amazon ECR (si es necesario)

   ```
   aws ecr create-repository \
       --repository-name lambda-appsignals-demo \
       --region $AWS_REGION
   ```

   Cree, etiquete y envíe imágenes de Docker

   ```
   # Build the Docker image
   docker build -t lambda-appsignals-demo .
   
   # Tag the image
   docker tag lambda-appsignals-demo:latest $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest
   
   # Push the image
   docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest
   
   5. Create and Configure the Lambda Function
   ```

1. **Cree y configure la función de Lambda**

   Cree una nueva función con la consola de Lambda.

   Seleccione **Imagen del contenedor** como opción de implementación.

   Elija **Examinar imágenes** para seleccionar su imagen de Amazon ECR.

1. **Pruebas y verificaciones: pruebe su Lambda con un evento simple. Si la integración de la capa se realiza correctamente, su Lambda aparecerá en el mapa de servicios de Application Signals.**

   Verá rastros y métricas de su función de Lambda en la consola de CloudWatch.

**Solución de problemas**

Si Application Signals no funciona, compruebe lo siguiente:
+ Compruebe los registros de la función para ver si hay algún error relacionado con la instrumentación de OpenTelemetry
+ Verifique si la variable de entorno `AWS_LAMBDA_EXEC_WRAPPER` está configurada correctamente
+ Asegúrese de que la extracción de la capa en el archivo de Docker se haya completado correctamente
+ Confirme si los permisos de IAM están correctamente asociados
+ Si es necesario, aumente los valores de *Tiempo de espera y memoria* en la configuración general de la función de Lambda

------
#### [ Python ]

Puede aprender a integrar la capa de OpenTelemetry compatible con Application Signals en su función de Lambda de Python en contenedores, descargar el `layer.zip` artefacto e integrarlo en su función Lambda de Python para habilitar la supervisión de Application Signals.

**Requisitos previos**
+ AWS CLI configurada con sus credenciales
+ Docker instalado
+ Estas instrucciones asumen que está en una plataforma x86\$164

1. **Configure la estructura del proyecto**

   Cree un directorio para la imagen del contenedor de su función de Lambda

   ```
   mkdir python-appsignals-container-lambda &&\
   cd python-appsignals-container-lambda
   ```

1. **Cree un archivo Dockerfile**

   Descargue e integre la capa de OpenTelemetry con soporte para Application Signals directamente en la imagen de contenedor de Lambda. Para ello, se crea el archivo `Dockerfile`.

   ```
   # Dockerfile
   
   FROM public.ecr.aws/lambda/python:3.13
   
   # Copy function code
   COPY app.py ${LAMBDA_TASK_ROOT}
   
   # Install unzip and wget utilities
   RUN dnf install -y unzip wget
   
   # Download the OpenTelemetry Layer with AppSignals Support
   RUN wget https://github.com/aws-observability/aws-otel-python-instrumentation/releases/latest/download/layer.zip -O /tmp/layer.zip
   
   # Extract and include Lambda layer contents
   RUN mkdir -p /opt && \
       unzip /tmp/layer.zip -d /opt/ && \
       chmod -R 755 /opt/ && \
       rm /tmp/layer.zip
   
   # Set the CMD to your handler
   CMD [ "app.lambda_handler" ]
   ```
**nota**  
El archivo `layer.zip` contiene la instrumentación de OpenTelemetry necesaria para que el soporte de AWS Application Signals pueda supervisar su función de Lambda.  
Los pasos de extracción de la capa garantizan lo siguiente:  
El contenido del archivo layer.zip se extrae correctamente en el `/opt/ directory`
El script `otel-instrument` recibe los permisos de ejecución adecuados
El archivo temporal layer.zip se elimina para reducir el tamaño de la imagen

1. **Código de la función de Lambda**

   Cree su función de Lambda en un archivo `app.py`:

   ```
   import json
   import boto3
   
   def lambda_handler(event, context):
       """
       Sample Lambda function that can be used in a container image.
   
       Parameters:
       -----------
       event: dict
           Input event data
       context: LambdaContext
           Lambda runtime information
   
       Returns:
       __
       dict
           Response object
       """
       print("Received event:", json.dumps(event, indent=2))
   
       # Create S3 client
       s3 = boto3.client('s3')
   
       try:
           # List buckets
           response = s3.list_buckets()
   
           # Extract bucket names
           buckets = [bucket['Name'] for bucket in response['Buckets']]
   
           return {
               'statusCode': 200,
               'body': json.dumps({
                   'message': 'Successfully retrieved buckets',
                   'buckets': buckets
               })
           }
       except Exception as e:
           print(f"Error listing buckets: {str(e)}")
           return {
               'statusCode': 500,
               'body': json.dumps({
                   'message': f'Error listing buckets: {str(e)}'
               })
           }
   ```

   La estructura de su proyecto debería tener un aspecto similar a este:

   ```
   .
   ├── Dockerfile
   ├── app.py
   └── instructions.md
   ```

1. **Cree e implemente la imagen de contenedor**

   **Configure las variables de entorno**

   ```
   AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
   AWS_REGION=$(aws configure get region)
   
   # For fish shell users:
   # set AWS_ACCOUNT_ID (aws sts get-caller-identity --query Account --output text)
   # set AWS_REGION (aws configure get region)
   ```

   Autenticarse con Amazon ECR público

   ```
   aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws
   ```

   Autenticarse con Amazon ECR privado

   ```
   aws ecr get-login-password --region $AWS_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com
   ```

   Cree un repositorio de Amazon ECR (si es necesario)

   ```
   aws ecr create-repository \
       --repository-name lambda-appsignals-demo \
       --region $AWS_REGION
   ```

   Cree, etiquete y envíe imágenes de Docker

   ```
   # Build the Docker image
   docker build -t lambda-appsignals-demo .
   
   # Tag the image
   docker tag lambda-appsignals-demo:latest $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest
   
   # Push the image
   docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest
   
   5. Create and Configure the Lambda Function
   ```

1. **Cree y configure la función de Lambda**

   Cree una nueva función con la consola de Lambda.

   Seleccione **Imagen del contenedor** como opción de implementación.

   Elija **Examinar imágenes** para seleccionar su imagen de Amazon ECR.

1. **Pruebas y verificaciones: pruebe su Lambda con un evento simple. Si la integración de la capa se realiza correctamente, su Lambda aparecerá en el mapa de servicios de Application Signals.**

   Verá rastros y métricas de su función de Lambda en la consola de CloudWatch.

**Solución de problemas**

Si Application Signals no funciona, compruebe lo siguiente:
+ Compruebe los registros de la función para ver si hay algún error relacionado con la instrumentación de OpenTelemetry
+ Verifique si la variable de entorno `AWS_LAMBDA_EXEC_WRAPPER` está configurada correctamente
+ Asegúrese de que la extracción de la capa en el archivo de Docker se haya completado correctamente
+ Confirme si los permisos de IAM están correctamente asociados
+ Si es necesario, aumente los valores de *Tiempo de espera y memoria* en la configuración general de la función de Lambda

------