Instrumentation en couches

Vous pouvez instrumenter votre fonction Lambda avec le quickstart newrelic-lambda CLI.

Pour installer ou mettre à niveau la couche d'instrumentation New Relic, exécutez cette commande :

$
newrelic-lambda layers install --nr-account-id YOUR_NR_ACCOUNT_ID --function my-function --upgrade --apm

Cette commande recherche automatiquement la couche la plus récente disponible pour la région et l'environnement d'exécution de votre Lambda.

Cette commande fournit un moyen rapide d'initier l'instrumentation New Relic et peut être facilement intégrée à votre pipeline CI/CD. Cependant, étant donné qu’il modifie les ressources de fonction Lambda existantes, le redéploiement du code mis à jour peut supprimer par inadvertance l’instrumentation. Pour assurer monitoring continue, réexécutez la commande après chaque déploiement ou, de préférence, intégrez la couche et la configuration New Relic directement dans votre processus de déploiement.

Notez que la CLI peut fonctionner sur de nombreuses fonctions dans un lot : utilisez --function all, --function installed ou --function not-installed pour fonctionner sur toutes les fonctions d'une région, ou uniquement celles avec ou sans instrumentation New Relic existante.

AWS's Serverless Application Model, or SAM, is a variant of CloudFormation templates that simplifies relating functions to the resources they depend on, and managing the lifecycle of an entire application. We use SAM and CloudFormation for most of our Lambda example functions, and many other tools are built on top of CloudFormation templates, providing an additional layer of abstraction.

CloudFormation est un service AWS qui simplifie l'approvisionnement et la gestion des ressources AWS. En définissant l'état souhaité des ressources dans les modèles YAML ou JSON, CloudFormation gère automatiquement l'appel d'API sous-jacent pour créer, mettre à jour ou supprimer des ressources selon les besoins. Cette approche déclarative automatise la gestion de l’infrastructure, garantissant cohérence et reproductibilité.

Pour monitorer votre fonction Lambda avec New Relic :

1. Install the New Relic Lambda layer. Below are examples for Node.js and Java agent Lambda functions.

   Node.js example:

   AWSTemplateFormatVersion: '2010-09-09'
   Transform: AWS::Serverless-2016-10-31
   Description: An example of a simple instrumented Node.js Lambda
   
   Resources:
     NewRelicExample:
       Type: AWS::Serverless::Function
       Properties:
         # In this example, we're using the SAM CLI to package and deploy our lambda. SAM will transform this value during the publish step.
         CodeUri: newrelic-example-node/
         # The handler for your function needs to be the one provided by the instrumentation layer, below.
         Handler: newrelic-lambda-wrapper.handler
         Runtime: nodejs22.x
         Environment:
           Variables:
             # For the instrumentation handler to invoke your real handler, we need this value
             NEW_RELIC_LAMBDA_HANDLER: YOUR_PATH_TO_INITIAL_LAMBDA_HANDLER
             # Distributed tracing needs your account ID, and your trusted account ID
             NEW_RELIC_ACCOUNT_ID: YOUR_ACCOUNT_ID_HERE
             # If your New Relic account has a parent account, this value should be that account ID. Otherwise, just
             # your account id.
             NEW_RELIC_TRUSTED_ACCOUNT_KEY: YOUR_PARENT_ACCOUNT_ID_HERE
             NEW_RELIC_APM_LAMBDA_MODE: 'true'
         Tags:
         # This tag is to enable APM mode.
           NR.Apm.Lambda.Mode: true
         Layers:
           # This layer includes the New Relic Lambda extension, a sidecar process that sends telemetry,
           # as well as the New Relic agent for Node.js, and a handler wrapper that makes integration easy.
           - !Sub arn:${AWS::Partition}:lambda:${AWS::Region}:451483290750:layer:NewRelicNodeJS16X:103
         Policies:
           # This policy allows the lambda to know the value of the New Relic license key. We need this so
           # that we can send telemetry back to New Relic
           - AWSSecretsManagerGetSecretValuePolicy:
               SecretArn: !ImportValue NewRelicLicenseKeySecret-NewRelic-LicenseKeySecretARN

   Copier

   En règle générale, vous disposerez d’un fichier nommé template.yaml qui décrit votre fonction et ses ressources.

   Java agent example (slim layer, recommended):

   Important

   The Java agent layer requires Java 17 or later. Java 11 and older runtimes are not supported.

   AWSTemplateFormatVersion: '2010-09-09'
   Transform: AWS::Serverless-2016-10-31
   Description: An example of a simple instrumented Java Lambda using the New Relic slim layer
   
   Resources:
     NewRelicJavaExample:
       Type: AWS::Serverless::Function
       Properties:
         CodeUri: my-java-function/
         # Set the handler to the New Relic Java HandlerWrapper.
         # Use handleRequest for RequestHandler implementations,
         # or handleStreamsRequest for RequestStreamHandler implementations.
         Handler: com.newrelic.java.HandlerWrapper::handleRequest
         Runtime: java17
         Environment:
           Variables:
             # Required: points AWS Lambda to the New Relic Java agent wrapper in the layer.
             AWS_LAMBDA_EXEC_WRAPPER: /opt/newrelic-java-handler
             # Required: your New Relic ingest license key.
             NEW_RELIC_LICENSE_KEY: YOUR_NEW_RELIC_LICENSE_KEY
             # Required: your New Relic account ID (or parent account ID if applicable).
             NEW_RELIC_TRUSTED_ACCOUNT_KEY: YOUR_ACCOUNT_ID_HERE
         Layers:
           # Slim layer (recommended): only aws-lambda-java-core instrumentation enabled.
           # Replace us-east-1 with your AWS region. Layer version increments with each release.
           # For the latest versions, see https://layers.newrelic-external.com
           # x86_64: arn:aws:lambda:us-east-1:451483290750:layer:NewRelicAgentJava-slim:1
           # ARM64:  arn:aws:lambda:us-east-1:451483290750:layer:NewRelicAgentJavaARM64-slim:1
           - arn:aws:lambda:us-east-1:451483290750:layer:NewRelicAgentJava-slim:1

   Copier

   Two layer variants are available for Java. Use the slim layer unless you need full auto-instrumentation:

   • Slim layer (recommended): Only instruments RequestHandler / RequestStreamHandler. Lower cold start overhead.
   • Full layer: All auto-instrumentation modules enabled. Higher cold start overhead.

   See Java serverless AWS Lambda performance monitoring for details on the two variants.

2. Configurez les variables d'environnement requises.

3. Déployez votre fonction Lambda avec la configuration mise à jour.

Serverless Framework est un outil de développement et de résolution de problèmes populaire pour les applications sans serveur. Il est écrit pour AWS en Node.js et agit principalement comme une abstraction de haut niveau sur les modèles CloudFormation. Il fonctionne bien pour les fonctions Node, Python, Ruby, Java et .NET.

New Relic propose un plug-in pour frameworkServerless afin de simplifier l'instrumentation de votre application Serverless.

Prérequis :

• Une application existante qui utilise le framework Serverless.

• ID de compte New Relic

• API de clé personnelle New Relic

  Pour installer et configurer votre application Serverless avec New Relic :

1. Si vous utilisez npm, exécutez la commande suivante :

   bash

   Copier

   $
   npm install --save-dev serverless-newrelic-lambda-layers

   OU, si vous utilisez yarn, exécutez la commande suivante :

   bash

   Copier

   $
   yarn add --dev serverless-newrelic-lambda-layers

2. Ouvrez votre fichier serverless.yaml et ajoutez la configuration suivante :

   1. Ajoutez serverless-newrelic-lambda-layers à votre liste plugins.

   2. Ajoutez la configuration New Relic suivante dans la section personnalisée :

      plugins:
        - serverless-newrelic-lambda-layers
      custom:
        newRelic:
          accountId: your-new-relic-account-id-here
          apiKey: your-new-relic-personal-api-key-here
          linkedAccount: your-new-relic-integration-account-name-here
          apm: true

      Copier

   3. Ajoutez la tag NR.Apm.Lambda.Mode: true suivante dans la section du fournisseur :

      provider:
        tags:
          NR.Apm.Lambda.Mode: true

      Copier

3. Configurez les variables d'environnement requises.

4. Déployez votre fonction Lambda avec la configuration mise à jour.

Le kit de développement cloud AWS (AWS CDK) est un framework permettant de définir des ressources cloud dans le code et de les provisionner via AWS CloudFormation.

Pour utiliser New Relic avec AWS CDK, suivez ces étapes :

1. Installez la couche Lambda de New Relic. Voici un exemple d'application CDK de base qui déploie une fonction Lambda Node.js instrumentée New Relic :

   import * as cdk from 'aws-cdk-lib';
   import { Construct } from 'constructs';
   import * as lambda from 'aws-cdk-lib/aws-lambda';
   
   export class NewRelicExampleCdkStack extends cdk.Stack {
     constructor(scope: Construct, id: string, props?: cdk.StackProps) {
       super(scope, id, props);
       // Add latest New Relic Lambda layer ARN from https://layers.newrelic-external.com
       const NewReliclayerArn = 'arn:aws:lambda:us-east-1:451483290750:layer:NewRelicNodeJS22X:38';
       const myFunction = new lambda.Function(this, "NewRelicExampleLambda", {
         runtime: lambda.Runtime.NODEJS_20_X,
         // Update functions handler to point to the New Relic Lambda wrapper
         handler: "newrelic-lambda-wrapper.handler",
         code: lambda.Code.fromAsset('lib/lambda-runtime-code'),
         layers: [lambda.LayerVersion.fromLayerVersionArn(this, 'NewRelicLayer', NewReliclayerArn)],
         environment: {
           // Set the NEW_RELIC_LAMBDA_HANDLER environment variable to the path of your initial handler.
           NEW_RELIC_LAMBDA_HANDLER: 'index.handler',
           NEW_RELIC_APM_LAMBDA_MODE: 'true'
         },
       });
       // Add the New Relic APM Lambda Mode tag
       cdk.Tags.of(myFunction).add('NR.Apm.Lambda.Mode', 'true');
     }
   }

   Copier

2. Configurez les variables d'environnement requises.

3. Déployez votre fonction Lambda avec la configuration mise à jour.

Terraform est un outil d'infrastructure en tant que code à usage général populaire. Il peut être utilisé pour gérer les ressources AWS. Nous proposons quelques exemples de New Relic instrumenté fonction Lambda déployée en utilisant le script Terraform.

Vous pouvez utiliser le fournisseur New Relic Terraform pour configurer votre intégration AWS. Lors de la configuration du fournisseur, configurez les variables d'environnement requises et ajoutez la tag NR.Apm.Lambda.Mode: true à votre fonction Lambda.

While it's more error-prone and labor-intensive than the approaches above, you can manually alter the configuration of a Lambda function to use New Relic from the AWS Lambda Console, for Node.js, Python, Ruby, and Java.

Voici un exemple de la manière d'instrumenter le monitoring Lambda de pour un environnement d'exécution Ruby :

1. Accédez à la section du service Lambda dans la console Web AWS. À partir de là, recherchez la fonction Lambda que vous souhaitez connecter à New Relic.

2. Dans l’onglet Code par défaut, faites défiler jusqu’à la section Layers et cliquez sur le bouton Add a layer .

3. Cliquez sur le bouton Create layer .

4. Accédez à Choose a layer et sélectionnez l’option Specify an ARN .

5. Accédez à la liste des couches de New Relic et utilisez la liste déroulante pour sélectionner la région AWS où votre fonction Lambda est hébergée. À partir de là, recherchez l’ARN qui correspond à la version et à l’architecture Ruby de votre fonction Lambda. Il devrait y avoir deux options : X86 et ARM64. Utilisez le bouton Copy to clipboard ou copiez manuellement la chaîne ARN.

6. Dans la section Specify an ARN du formulaire de la console AWS, collez l’ARN de la couche New Relic Lambda.

7. Dans le formulaire de la console AWS, cliquez sur le bouton Add pour ajouter la couche à votre fonction Lambda.

8. Sur la page de votre fonction Lambda, avec l’onglet Code par défaut sélectionné, faites défiler jusqu’à la section Runtime settings et cliquez sur le bouton Edit .

9. Créez une copie sécurisée de la valeur du gestionnaire (Handler) existante. Vous en aurez besoin pour une étape ultérieure.

10. Modifiez la valeur du gestionnaire (Handler) sur : newrelic_lambda_wrapper.handler et cliquez sur Save.

11. Passez à l'onglet de Configuration sur la page de votre fonction Lambda.

12. Sélectionnez le sous-onglet Environment variables et, en fonction de vos besoins, définissez les variables d’environnement.

13. Modifiez le rôle d’exécution pour autoriser l’accès au secret de la clé de licence New Relic.

    • Trouvez l'ARN du secret nommé NEW_RELIC_LICENSE_KEY.

    • Ajoutez une nouvelle politique en ligne dans le rôle d’exécution de la fonction qui ressemble au code ci-dessous. Remplacez le SECRET_ARN par la valeur que vous avez trouvée ci-dessus.

      "Statement": [
        {
          "Action": [
            "secretsmanager:GetSecretValue"
          ],
          "Resource": "SECRET_ARN",
          "Effect": "Allow"
        }
      ]

      Copier

      Conseil

      La couche New Relic fournira automatiquement l'agent New Relic Ruby et sera chargée via un Ruby require avant l'appel de votre fonction Lambda. Pour éviter les conflits, n'incluez pas de copie de l'agent Ruby ailleurs. N'hésitez pas à effectuer tous les appels d'agent API New Relic Ruby souhaités au sein de votre fonction pour profiter de la présence de l'agent.

14. Dans votre console de gestion AWS, dans l'onglet configuration, ajoutez la tag NR.Apm.Lambda.Mode: true à votre fonction Lambda.

15. Déployez votre fonction Lambda avec la configuration mise à jour.

    Les environnements d'exécution Java, Python, Node.js et .Net suivront le même flux d'instrumentation que Ruby, mais avec des gestionnaires différents. Voici comment mettre à jour le gestionnaire de votre fonction pour qu'il pointe vers la couche nouvellement attachée dans la console pour votre fonction :

• Java:

  • RequestHandler implémentation : com.newrelic.java.HandlerWrapper::handleRequest.
  • RequestStreamHandler implémentation : com.newrelic.java.HandlerWrapper::handleStreamsRequest.

• Python : newrelic_lambda_wrapper.handler (soulignements).

• Nœud:

  • CommonJS : newrelic-lambda-wrapper.handler (traits d'union).
  • ESM : /opt/nodejs/node_modules/newrelic-esm-lambda-wrapper/index.handler (traits d’union).

• Pour .Net, vous n'avez pas besoin de définir le gestionnaire.

  Notez que pour Go, vous devez apporter des modifications au code source de votre fonction Lambda pour l'instrumenter. Les changements de configuration ne suffisent pas.