Puedes instrumentar tu aplicación AWS Lambda en Python directamente dentro de Datadog. Navega a la página Serverless > AWS Lambda y selecciona Instrumentar Funciones.

Para más información, consulta Instrumentación remota para AWS Lambda.

El CLI de Datadog modifica las configuraciones de las funciones Lambda existentes para habilitar la instrumentación sin requerir un nuevo despliegue. Es la forma más rápida de comenzar con el monitoreo serverless de Datadog.

1. Instalar el cliente CLI de Datadog

   npm install -g @datadog/datadog-ci @datadog/datadog-ci-plugin-lambda
   

2. Si eres nuevo en Serverless Monitoring de Datadog, lanza la CLI de Datadog en modo interactivo para guiar tu primera instalación para un inicio rápido, y puedes ignorar los pasos restantes. Para instalar Datadog permanentemente en tus aplicaciones de producción, omite este paso y sigue los restantes para ejecutar el comando de la CLI de Datadog en tus canalizaciones de CI/CD después de tu despliegue normal.

   datadog-ci lambda instrument -i
   

3. Configura las credenciales de AWS

   La CLI de Datadog requiere acceso al servicio AWS Lambda y depende del SDK de JavaScript de AWS para [resolver las credenciales][1]. Asegúrate de que tus credenciales de AWS estén configuradas utilizando el mismo método que usarías al invocar la CLI de AWS.

4. Configura el sitio de Datadog

   export DATADOG_SITE="<DATADOG_SITE>"
   

   Replace <DATADOG_SITE> with (asegúrate de que el SITIO correcto esté seleccionado a la derecha).

5. Configura la clave API de Datadog

   Datadog recomienda guardar la clave API de Datadog en AWS Secrets Manager por seguridad y fácil rotación. La clave debe ser almacenada como una cadena de texto sin formato (no un blob JSON). Asegúrate de que tus funciones Lambda tengan el permiso secretsmanager:GetSecretValue IAM requerido.

   export DATADOG_API_KEY_SECRET_ARN="<DATADOG_API_KEY_SECRET_ARN>"
   

   For quick testing purposes, you can also set the Datadog API key in plaintext:

   export DATADOG_API_KEY="<DATADOG_API_KEY>"
   

6. Instrumenta tus funciones Lambda

   Nota: Instrumenta tus funciones Lambda primero en un entorno de desarrollo o de pruebas. Si el resultado de la instrumentación no es satisfactorio, ejecuta uninstrument con los mismos argumentos para revertir los cambios.

   Para instrumentar tus funciones Lambda, ejecuta el siguiente comando.

   datadog-ci lambda instrument -f <functionname> -f <another_functionname> -r <aws_region> -v 125 -e 97
   

    To fill in the placeholders:
    - Replace `<functionname>` and `<another_functionname>` with your Lambda function names. Alternatively, you can use `--functions-regex` to automatically instrument multiple functions whose names match the given regular expression.
    - Replace `<aws_region>` with the AWS region name.

    Additional parameters can be found in the [CLI documentation][2].


[1]: https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-credentials-node.html
[2]: https://docs.datadoghq.com/es/serverless/serverless_integrations/cli

El Plugin Serverless de Datadog configura automáticamente tus funciones para enviar métricas, trazas y registros a Datadog a través de la Extensión Lambda de Datadog.

Para instalar y configurar el Plugin Serverless de Datadog, sigue estos pasos:

1. Instala el complemento sin servidor de Datadog:

   serverless plugin install --name serverless-plugin-datadog
   

2. Actualiza tu serverless.yml:

   custom:
     datadog:
       site: <DATADOG_SITE>
       apiKeySecretArn: <DATADOG_API_KEY_SECRET_ARN>
   

   To fill in the placeholders:

   • Replace <DATADOG_SITE> with (asegúrate de que el SITIO correcto esté seleccionado a la derecha).
   • Reemplaza <DATADOG_API_KEY_SECRET_ARN> con el ARN del secreto de AWS donde tu clave de API de Datadog está almacenada de forma segura. La clave debe ser almacenada como una cadena de texto sin formato (no un blob JSON). Se requiere el permiso secretsmanager:GetSecretValue. Para pruebas rápidas, puedes usar apiKey y establecer la clave de API de Datadog en texto plano.

   For more information and additional settings, see the plugin documentation.

El macro de CloudFormation de Datadog transforma automáticamente tu plantilla de aplicación SAM para instalar Datadog en tus funciones utilizando capas de Lambda, y configura tus funciones para enviar métricas, trazas y registros a Datadog a través de la Extensión de Lambda de Datadog.

1. Instala el macro de CloudFormation de Datadog

   Ejecuta el siguiente comando con tus credenciales de AWS para desplegar una pila de CloudFormation que instala el recurso macro de AWS. Solo necesitas instalar el macro una vez para una región dada en tu cuenta. Reemplaza create-stack con update-stack para actualizar el macro a la última versión.

   aws cloudformation create-stack \
     --stack-name datadog-serverless-macro \
     --template-url https://datadog-cloudformation-template.s3.amazonaws.com/aws/serverless-macro/latest.yml \
     --capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_IAM
   

   The macro is now deployed and ready to use.

2. Instrumenta tus funciones Lambda

   Agrega la transformación DatadogServerless después de la transformación AWS::Serverless en la sección Transform de tu archivo template.yml para SAM.

   Transform:
     - AWS::Serverless-2016-10-31
     - Name: DatadogServerless
       Parameters:
         stackName: !Ref "AWS::StackName"
         pythonLayerVersion: 125
         extensionLayerVersion: 97
         site: "<DATADOG_SITE>"
         apiKeySecretArn: "<DATADOG_API_KEY_SECRET_ARN>"
   

   To fill in the placeholders:

   • Replace <DATADOG_SITE> with (asegúrate de que el SITIO correcto esté seleccionado a la derecha).
   • Reemplaza <DATADOG_API_KEY_SECRET_ARN> con el ARN del secreto de AWS donde tu clave de API de Datadog está almacenada de forma segura. La clave debe ser almacenada como una cadena de texto sin formato (no un blob JSON). Se requiere el permiso secretsmanager:GetSecretValue. Para pruebas rápidas, puedes usar apiKey en su lugar y establecer la clave de API de Datadog en texto plano.

   More information and additional parameters can be found in the macro documentation.

The Datadog CDK construct automatically installs Datadog on your functions using Lambda layers. It configures your functions to send metrics, traces, and logs to Datadog through the Datadog Lambda Extension.

TypeScript

1. Install the Datadog CDK constructs library

   For AWS CDK v1:

   npm install datadog-cdk-constructs --save-dev
   

   For AWS CDK v2:

   npm install datadog-cdk-constructs-v2 --save-dev
   

2. Instrument your Lambda functions

   For AWS CDK v1:

   import { Datadog } from "datadog-cdk-constructs";
   
   const datadog = new Datadog(this, "Datadog", {
       pythonLayerVersion: 125,
       extensionLayerVersion: 97,
       site: "<DATADOG_SITE>",
       apiKeySecretArn: "<DATADOG_API_KEY_SECRET_ARN>"
   });
   datadog.addLambdaFunctions([<LAMBDA_FUNCTIONS>])
   

   For AWS CDK v2:

   import { DatadogLambda } from "datadog-cdk-constructs-v2";
   
   const datadogLambda = new DatadogLambda(this, "datadogLambda", {
       pythonLayerVersion: 125,
       extensionLayerVersion: 97,
       site: "<DATADOG_SITE>",
       apiKeySecretArn: "<DATADOG_API_KEY_SECRET_ARN>"
   });
   datadogLambda.addLambdaFunctions([<LAMBDA_FUNCTIONS>])
   

Python

1. Install the Datadog CDK constructs library

   For AWS CDK v1:

   pip install datadog-cdk-constructs
   

   For AWS CDK v2:

   pip install datadog-cdk-constructs-v2
   

2. Instrument your Lambda functions

   For AWS CDK v1:

   from datadog_cdk_constructs import Datadog
   datadog = Datadog(self, "Datadog",
       python_layer_version=125,
       extension_layer_version=97,
       site="<DATADOG_SITE>",
       api_key_secret_arn="<DATADOG_API_KEY_SECRET_ARN>",
     )
   datadog.add_lambda_functions([<LAMBDA_FUNCTIONS>])
   

   For AWS CDK v2:

   from datadog_cdk_constructs_v2 import DatadogLambda
   
   datadog = DatadogLambda(self, "datadogLambda",
       python_layer_version=125,
       extension_layer_version=97,
       site="<DATADOG_SITE>",
       api_key_secret_arn="<DATADOG_API_KEY_SECRET_ARN>",
     )
   datadog.add_lambda_functions([<LAMBDA_FUNCTIONS>])
   

Go

Note: Go CDK constructs are only available for AWS CDK v2.

1. Install the Datadog CDK constructs library

   go get github.com/DataDog/datadog-cdk-constructs-go/ddcdkconstruct/v3
   

2. Instrument your Lambda functions

   import (
       "github.com/DataDog/datadog-cdk-constructs-go/ddcdkconstruct/v3"
   )
   
   datadogLambda := ddcdkconstruct.NewDatadogLambda(
       stack,
       jsii.String("Datadog"),
       &ddcdkconstruct.DatadogLambdaProps{
           PythonLayerVersion:      jsii.Number(125),
           ExtensionLayerVersion: jsii.Number(97),
           Site:                  jsii.String("<DATADOG_SITE>"),
           ApiKeySecretArn:       jsii.String("<DATADOG_API_KEY_SECRET_ARN>"),
       })
   datadogLambda.AddLambdaFunctions(&[]interface{}{<LAMBDA_FUNCTIONS>}, nil)
   

To fill in the placeholders:

• Replace <DATADOG_SITE> with (ensure the correct SITE is selected on the right).
• Replace <DATADOG_API_KEY_SECRET_ARN> with the ARN of the AWS secret where your Datadog API key is securely stored. The key needs to be stored as a plaintext string (not a JSON blob). Ensure your Lambda execution role has the secretsmanager:GetSecretValue IAM permission in order to read the secret value. For quick testing, you can use apiKey instead and set the Datadog API key in plaintext.

More information and additional parameters can be found on the Datadog CDK documentation.

1. Instala la biblioteca de Lambda de Datadog

   Si estás implementando tu función Lambda como una imagen de contenedor, no puedes usar la biblioteca Datadog Lambda como una capa de Lambda. En su lugar, debes instalar la biblioteca Datadog Lambda como una dependencia de tu función dentro de la imagen.

   pip install datadog-lambda
   

   Note that the minor version of the datadog-lambda package always matches the layer version. For example, datadog-lambda v0.5.0 matches the content of layer version 5.

2. Instala la Extensión Datadog Lambda

   Agrega la Extensión Datadog Lambda a tu imagen de contenedor añadiendo lo siguiente a tu Dockerfile:

   COPY --from=public.ecr.aws/datadog/lambda-extension:<TAG> /opt/. /opt/
   

   Replace <TAG> with either a specific version number (for example, 97) or with último. Alpine is also supported with specific version numbers (such as 97-alpine) or with último-alpine. Puedes ver una lista completa de posibles etiquetas en el repositorio de Amazon ECR.

3. Redirige la función manejadora

   • Establece el valor de CMD de tu imagen a datadog_lambda.handler.handler. Puedes establecer esto en AWS o directamente en tu Dockerfile. Ten en cuenta que el valor establecido en AWS anula el valor en el Dockerfile si estableces ambos.
   • Establece la variable de entorno DD_LAMBDA_HANDLER a tu manejador original, por ejemplo, myfunc.handler.

   Nota: Si estás utilizando una herramienta de seguridad o monitoreo de terceros que es incompatible con la redirección del manejador Datadog, puedes aplicar el envoltorio de Datadog en el código de tu función en su lugar.

4. Configura el sitio de Datadog, la clave de API y el trazado en tu Dockerfile

   • Establece la variable de entorno DD_SITE a (asegúrate de que el SITIO correcto esté seleccionado a la derecha).
   • Establece la variable de entorno DD_API_KEY_SECRET_ARN con el ARN del secreto de AWS donde se almacena de forma segura tu clave API de Datadog. La clave debe ser almacenada como una cadena de texto sin formato (no un blob JSON). Se requiere el permiso secretsmanager:GetSecretValue. Para pruebas rápidas, puedes usar DD_API_KEY en su lugar y establecer la clave de API de Datadog en texto plano.
   • Establece la variable de entorno DD_TRACE_ENABLED a true.

El módulo de Terraform lambda-datadog envuelve el recurso aws_lambda_function y configura automáticamente tu función Lambda para el monitoreo Serverless de Datadog mediante:

• Agregando las capas de Lambda de Datadog
• Redirigiendo el controlador de Lambda
• Habilitando la recolección y el envío de métricas, trazas y registros a Datadog

module "lambda-datadog" {
  source  = "DataDog/lambda-datadog/aws"
  version = "4.0.0"

  environment_variables = {
    "DD_API_KEY_SECRET_ARN" : "<DATADOG_API_KEY_SECRET_ARN>"
    "DD_ENV" : "<ENVIRONMENT>"
    "DD_SERVICE" : "<SERVICE_NAME>"
    "DD_SITE": "<DATADOG_SITE>"
    "DD_VERSION" : "<VERSION>"
  }

  datadog_extension_layer_version = 97
  datadog_python_layer_version = 125

  # aws_lambda_function arguments
}

1. Reemplaza el recurso aws_lambda_function con el módulo de Terraform lambda-datadog. Luego, especifica el source y el version del módulo.

2. Establece los argumentos aws_lambda_function:

   Todos los argumentos disponibles en el recurso aws_lambda_function están disponibles en este módulo de Terraform. Los argumentos definidos como bloques en el recurso aws_lambda_function se redefinen como variables con sus argumentos anidados.

   Por ejemplo, en aws_lambda_function, environment se define como un bloque con un argumento variables. En el módulo de Terraform lambda-datadog, el valor para el environment_variables se pasa al argumento environment.variables en aws_lambda_function. Consulta inputs para una lista completa de variables en este módulo.

3. Complete los marcadores de posición de las variables de entorno:

   • Reemplace <DATADOG_API_KEY_SECRET_ARN> con el ARN del secreto de AWS donde se almacena de forma segura su clave API de Datadog. La clave debe ser almacenada como una cadena de texto sin formato (no un blob JSON). Se requiere el permiso secretsmanager:GetSecretValue. Para pruebas rápidas, puede usar en su lugar la variable de entorno DD_API_KEY y establecer su clave API de Datadog en texto plano.
   • Reemplace <ENVIRONMENT> con el entorno de la función Lambda, como prod o staging
   • Reemplace <SERVICE_NAME> con el nombre del servicio de la función Lambda
   • Reemplace <DATADOG_SITE> con . (Asegúrese de que el sitio de Datadog correcto esté seleccionado en esta página).
   • Reemplace <VERSION> con el número de versión de la función Lambda

4. Seleccione las versiones de la capa de extensión de Datadog Lambda y la capa de Datadog Python Lambda que desea utilizar. Si se deja en blanco, se utilizarán las versiones más recientes de la capa.

  datadog_extension_layer_version = 97
  datadog_python_layer_version = 125

Para configurar Datadog usando SST v3, siga estos pasos:

const app = new sst.aws.Function("MyApp", {
  handler: "lambda_function.lambda_handler",
  runtime: "python3.13",
  environment: {
    DD_ENV: "<ENVIRONMENT>",
    DD_SERVICE: "<SERVICE_NAME>",
    DD_VERSION: "<VERSION>",
    DATADOG_API_KEY_SECRET_ARN: "<DATADOG_API_KEY_SECRET_ARN>",
    DD_SITE: "<DATADOG_SITE>",
  },
  layers: [
    $interpolate`arn:aws:lambda:${aws.getRegionOutput().name}:464622532012:layer:Datadog-Extension:97`,
    $interpolate`arn:aws:lambda:${aws.getRegionOutput().name}:464622532012:layer:Datadog-<RUNTIME>:125`
  ]
});

1. Configure the Datadog Lambda Library and Datadog Lambda Extension layers

   • The available <RUNTIME> options are: Python38, Python39, Python310, Python311, Python312, Python313, Python314.

2. Complete los marcadores de posición de las variables de entorno:

   • Reemplace <DATADOG_API_KEY_SECRET_ARN> con el ARN del secreto de AWS donde se almacena de forma segura su clave API de Datadog. La clave debe ser almacenada como una cadena de texto sin formato (no un blob JSON). Se requiere el permiso secretsmanager:GetSecretValue. Para pruebas rápidas, puedes usar en su lugar la variable de entorno DD_API_KEY y establecer tu clave de API de Datadog en texto plano.
   • Reemplace <ENVIRONMENT> con el entorno de la función Lambda, como prod o staging
   • Reemplace <SERVICE_NAME> con el nombre del servicio de la función Lambda
   • Reemplace <DATADOG_SITE> con . (Asegúrese de que el sitio de Datadog correcto esté seleccionado en esta página).
   • Reemplace <VERSION> con el número de versión de la función Lambda

3. Aplique el envoltorio de Datadog en el código de su función

1. Instale la biblioteca de Lambda de Datadog

   La biblioteca de Lambda de Datadog se puede importar ya sea como una capa (recomendada) O como un paquete de Python.

   La versión menor del datadog-lambda paquete siempre coincide con la versión de la capa. Por ejemplo, datadog-lambda v0.5.0 coincide con el contenido de la versión de la capa 5.

   • Opción A: [Configure las capas][1] para su función Lambda utilizando el ARN en el siguiente formato:

     # Use this format for x86-based Lambda deployed in AWS commercial regions
     arn:aws:lambda:<AWS_REGION>:464622532012:layer:Datadog-<RUNTIME>:125
     
     # Use this format for arm64-based Lambda deployed in AWS commercial regions
     arn:aws:lambda:<AWS_REGION>:464622532012:layer:Datadog-<RUNTIME>-ARM:125
     
     # Use this format for x86-based Lambda deployed in AWS GovCloud regions
     arn:aws-us-gov:lambda:<AWS_REGION>:002406178527:layer:Datadog-<RUNTIME>:125
     
     # Use this format for arm64-based Lambda deployed in AWS GovCloud regions
     arn:aws-us-gov:lambda:<AWS_REGION>:002406178527:layer:Datadog-<RUNTIME>-ARM:125
     

     Replace <AWS_REGION> with a valid AWS region, such as us-east-1. The available <RUNTIME> options are: Python38, Python39, Python310, Python311, Python312, Python313, Python314.

   • Option B: If you cannot use the prebuilt Datadog Lambda layer, alternatively install the datadog-lambda package and its dependencies locally to your function project folder using your favorite Python package manager, such as pip.

     pip install datadog-lambda -t ./
     

     Note: datadog-lambda depends on ddtrace, which uses native extensions; therefore it must be installed and compiled in a Linux environment on the right architecture (x86_64 or arm64). For example, you can use [dockerizePip][2] for the Serverless Framework and [–use-container][3] for AWS SAM. For more details, see [how to add dependencies to your function deployment package][4].

     See the [latest release][5].

2. Instale la Lambda Extension de Datadog

   [Configure las capas][1] para su función Lambda utilizando el ARN en el siguiente formato:

   # Use this format for x86-based Lambda deployed in AWS commercial regions
   arn:aws:lambda:<AWS_REGION>:464622532012:layer:Datadog-Extension:97
   
   # Use this format for arm64-based Lambda deployed in AWS commercial regions
   arn:aws:lambda:<AWS_REGION>:464622532012:layer:Datadog-Extension-ARM:97
   
   # Use this format for x86-based Lambda deployed in AWS GovCloud regions
   arn:aws-us-gov:lambda:<AWS_REGION>:002406178527:layer:Datadog-Extension:97
   
   # Use this format for arm64-based Lambda deployed in AWS GovCloud regions
   arn:aws-us-gov:lambda:<AWS_REGION>:002406178527:layer:Datadog-Extension-ARM:97
   

    Replace `<AWS_REGION>` with a valid AWS region, such as `us-east-1`.

3. Redirija la función manejadora

    - Establezca el manejador de su función a `datadog_lambda.handler.handler`.
    - Establezca la variable de entorno `DD_LAMBDA_HANDLER` a su manejador original, por ejemplo, `myfunc.handler`.

    **Nota**: Si está utilizando una herramienta de seguridad o monitoreo de terceros que es incompatible con la redirección del manejador de Datadog, puede [Aplique el envoltorio de Datadog en el código de su función][6] en su lugar.

4. Configure el sitio de Datadog, la clave de API y el rastreo

    - Establezca la variable de entorno `DD_SITE` a <code class="js-region-param region-param" data-region-param="dd_site"></code> (Asegúrese de que el SITIO correcto esté seleccionado a la derecha).
    - Establezca la variable de entorno `DD_API_KEY_SECRET_ARN` con el ARN del secreto de AWS donde su [clave de API de Datadog][7] está almacenada de forma segura. La clave necesita ser almacenada como una cadena de texto sin formato, en lugar de estar dentro de un blob JSON. Se requiere el permiso `secretsmanager:GetSecretValue`. Para pruebas rápidas, puede usar `DD_API_KEY` en su lugar y establecer la clave de API de Datadog en texto sin formato.
    - Establezca la variable de entorno `DD_TRACE_ENABLED` a `true`.

5. (Solo AWS Chalice) Registre el middleware

    Si está utilizando [AWS Chalice][8], debe instalar `datadog-lambda` usando `pip`, y registrar `datadog_lambda_wrapper` como un [middleware][9] en su `app.py`:

    ```python
    from chalice import Chalice, ConvertToMiddleware
    from datadog_lambda.wrapper import datadog_lambda_wrapper

    app = Chalice(app_name='hello-chalice')

    app.register_middleware(ConvertToMiddleware(datadog_lambda_wrapper))

    @app.route('/')
    def index():
        return {'hello': 'world'}
    ```

[1]: https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html
[2]: https://github.com/UnitedIncome/serverless-python-requirements#cross-compiling
[3]: https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-build.html
[4]: https://docs.aws.amazon.com/lambda/latest/dg/python-package.html#python-package-dependencies
[5]: https://pypi.org/project/datadog-lambda/
[6]: https://docs.datadoghq.com/es/serverless/guide/handler_wrapper
[7]: https://app.datadoghq.com/organization-settings/api-keys
[8]: https://aws.github.io/chalice/
[9]: https://aws.github.io/chalice/topics/middleware.html