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

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.

Le modèle d'application Serverless d'AWS, ou SAM, est une variante des modèles CloudFormation qui simplifie la relation entre les fonctions et les ressources dont elles dépendent et la gestion du cycle de vie d'une application entière. Nous utilisons SAM et CloudFormation pour la plupart de nos fonctions d’exemple Lambda, et de nombreux autres outils sont construits sur des modèles CloudFormation, offrant une couche d’abstraction supplémentaire.

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é.

Voici un exemple de modèle CloudFormation simple pour une fonction Lambda Node.js :

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: And 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: nodejs12.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
      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:NewRelicNodeJS12X:34
      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

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

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 plugin de Framework Serverless pour simplifier l'instrumentation de votre application de framework Serverless .

Pour installer le plugin, exécutez cette commande :

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

Ou, alternativement, vous pouvez exécuter cette commande :

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

Ensuite, recherchez votre identifiant de compte New Relic, votre clé API personnelle New Relic

Ajoutez maintenant ce qui suit à votre fichier serverless.yaml :

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

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.

Vous trouverez ci-dessous un exemple d'application CDK de base qui déploie une fonction instrumentée par New Relic Node.js Lambda:

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:NewRelicNodeJS20X:39';
    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',
      },
    });
  }
}

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.

Bien que cela soit plus sujet aux erreurs et demande plus de travail que les approches ci-dessus, vous pouvez modifier manuellement la configuration d'une fonction Lambda pour utiliser New Relic à partir de la console AWS Lambda, pour Node.js, Python, Ruby et 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.

    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.
  • RequestStreamHandlerWrapper 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.

Chaque couche d'agent contient également une extension pour envoyer les logs et les frais à New Relic, en contournant CloudWatch. Cela peut aider à réduire la latence et les coûts. Cependant, cela comporte le risque d’impacter les performances et la fiabilité de votre fonction.

Après avoir ajouté une couche New Relic Lambda , l'extension est activée et l'expédition log est désactivée par défaut.

Si vous souhaitez voir les logs des fonctions dans New Relic, vous devrez activer l'envoi d'extension des logs des fonctions avec une variable d'environnement.

Il est important de noter que les logs de fonction ne sont pas que les logs enregistrés par la fonction lors de son appel. L'extension n'enverra pas de logs d'exécution Lambda comme les lignes START, END et REPORT.

Vous pouvez choisir d'envoyer des données à CloudWatch uniquement ou en tant que solution de secours. Pour en savoir plus, veuillez consulter notre documentation de secours CloudWatch.