instrumento sua função não-containerizada do Lambda

Você pode instrumentar sua função do Lambda com o newrelic-lambda CLI início rápido.

Para instalar ou atualizar a camada de instrumentação New Relic, execute este comando:

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

Este comando encontra automaticamente a camada disponível mais recente para a região e o tempo de execução do seu Lambda.

Este comando fornece uma maneira rápida de iniciar a instrumentação do New Relic e pode ser facilmente integrado ao seu pipeline de CI/CD. No entanto, uma vez que modifica os recursos existentes da função do Lambda, a reimplantação do código atualizado pode remover inadvertidamente a instrumentação. Para garantir o monitoramento contínuo, execute novamente o comando após cada implantação ou, de preferência, incorpore a camada e a configuração do New Relic diretamente em seu processo de implantação.

Observe que a CLI pode operar em muitas funções em um lote: use --function all, --function installed ou --function not-installed para operar em todas as funções em uma região ou apenas naquelas com ou sem instrumentação New Relic existente.

O modelo de aplicativo serverless da AWS, ou SAM, é uma variante dos modelos CloudFormation que simplifica o relacionamento de funções com os recursos dos quais dependem e o gerenciamento do ciclo de vida de um aplicativo inteiro. Usamos SAM e CloudFormation para a maioria de nossas funções de exemplo do Lambda, e muitas outras ferramentas são construídas sobre modelos do CloudFormation, fornecendo uma camada adicional de abstração.

CloudFormation é um serviço da AWS que simplifica o provisionamento e gerenciamento de recursos AWS . Ao definir o estado desejado dos recursos em modelos YAML ou JSON, o CloudFormation lida automaticamente com a chamada de API subjacente para criar, atualizar ou excluir recursos conforme necessário. Esta abordagem declarativa automatiza o gerenciamento da infraestrutura, garantindo consistência e reprodutibilidade.

Aqui está um exemplo de um modelo simples do CloudFormation para uma função do Lambda do 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

Normalmente, você terá um arquivo chamado template.yaml que descreve sua função e seus recursos.

framework sem servidor é uma ferramenta popular de desenvolvimento e implantação de aplicativos sem servidor. Ele foi escrito para AWS em Node.js e atua principalmente como uma abstração de alto nível sobre modelos CloudFormation. Funciona bem para funções Node, Python, Ruby, Java e .NET.

A New Relic oferece um plug-in framework Serverless para simplificar a instrumentação de seu aplicativo framework Serverless.

Para instalar o plug-in, execute este comando:

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

Ou, alternativamente, você pode executar este comando:

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

Em seguida, encontre seu ID de conta New Relic, sua chave de API pessoal New Relic

Agora adicione o seguinte ao seu arquivo 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

O Nuvem da AWS Development Kit (AWS CDK) é um framework para definir recursos de nuvem em código e provisioná-los por meio do AWS CloudFormation.

Abaixo está um exemplo de um aplicativo CDK básico que implanta uma função New Relic instrumentada Node.js do 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 é uma infraestrutura popular de uso geral como ferramenta de código. Ele pode ser usado para gerenciar recursos da AWS. Oferecemos alguns exemplos de New Relic instrumentado com função de implantação Lambda usando script Terraform.

Você pode usar o provedor New Relic Terraform para configurar sua integração AWS .

Embora seja mais propenso a erros e trabalhoso do que as abordagens acima, você pode alterar manualmente a configuração de uma função do Lambda para usar New Relic do AWS Lambda Console, para Node.js, Python, Ruby e Java.

Aqui está um exemplo de como configurar o monitoramento Lambda do New Relic para um runtime Ruby :

1. Navegue até a seção de serviço Lambda no console web da AWS. A partir daí, encontre a função do Lambda que você gostaria de conectar ao New Relic.

2. Na guia Code padrão, role para baixo até a seção Layers e clique no botão Add a layer .

3. Clique no botão Create layer .

4. Vá para Choose a layer e selecione a opção Specify an ARN .

5. Vá para a New Relic's list of layers e use a lista suspensa para selecionar a região AWS onde sua função do Lambda está hospedada. A partir daí, localize o ARN que corresponde à versão e arquitetura Ruby da sua Função do Lambda. Deve haver duas opções: X86 e ARM64. Use o botão Copy to clipboard ou copie manualmente a string ARN.

6. Na seção Specify an ARN do formulário do console AWS, cole o ARN da camada New Relic Lambda.

7. No formulário do console AWS , clique no botão Add para adicionar a camada à sua função do Lambda.

8. Na página da sua Função do Lambda, com a guia Code padrão selecionada, role para baixo até a seção Runtime settings e clique no botão Edit .

9. Faça uma cópia segura do valor existente do Handler . Você precisará dele em uma etapa posterior.

10. Altere o valor do Handler para: newrelic_lambda_wrapper.handler e clique em Save.

11. Mude para a aba Configuration na página da sua função do Lambda.

12. Selecione a subguia Environment variables .

13. Defina as seguintes variáveis de ambiente:

    • NEW_RELIC_ACCOUNT_ID: Defina o ID da sua conta New Relic.

    • NEW_RELIC_LAMBDA_HANDLER: defina como o valor do manipulador original da sua função copiado anteriormente.

      • NEW_RELIC_LICENSE_KEY: defina como sua chave de licença do New Relic.
      • NEW_RELIC_LOG_ENDPOINT: defina como https://log-api.newrelic.com/log/v1.
      • NEW_RELIC_TELEMETRY_ENDPOINT: defina como https://cloud-collector.newrelic.com/aws/lambda/v1.

14. Se você deseja enviar o log da sua função do Lambda para New Relic, que incluirá tudo o que sua função grava em STDOUT, certifique-se de definir a variável de ambiente NEW_RELIC_EXTENSION_SEND_FUNCTION_LOGS como true.

15. Modifique a função de execução para permitir acesso ao segredo da chave de licença do New Relic.

    • Encontre o ARN do segredo chamado NEW_RELIC_LICENSE_KEY.

    • Adicione uma nova política embutida na função de execução da função semelhante ao código abaixo. Substitua SECRET_ARN pelo valor encontrado acima.

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

      Copiar

      Dica

      A camada New Relic entregará automaticamente o agente New Relic Ruby e será carregada por meio de um Ruby require antes da invocação da sua função do Lambda. Para evitar conflitos, não inclua uma cópia do agente Ruby em nenhum outro lugar. Sinta-se à vontade para realizar qualquer chamada de API do agente New Relic Ruby desejada em sua função para aproveitar a presença do agente.

    Os tempos de execução Java, Python, Node.js e .Net seguirão o mesmo fluxo de instrumentação do Ruby, mas com alguns manipuladores diferentes. Veja como atualizar o manipulador da sua função para apontar para a camada recém-anexada no console da sua função:

• Java:

  • RequestHandler implementação: com.newrelic.java.HandlerWrapper::handleRequest.
  • RequestStreamHandlerWrapper implementação: com.newrelic.java.HandlerWrapper::handleStreamsRequest.

• Python: newrelic_lambda_wrapper.handler (sublinhados).

• Nó: newrelic-lambda-wrapper.handler (hífens).

• Para .Net você não precisa definir o manipulador.

  Observe que para o Go, você deve fazer alterações no código-fonte da sua função do Lambda para instrumentá-lo. As alterações de configuração não são suficientes.

Cada camada de agente também contém uma extensão para enviar log e carga para o New Relic, ignorando o CloudWatch. Isso pode ajudar a reduzir a latência e os custos. No entanto, corre o risco de afetar o desempenho e a confiabilidade de sua função.

Depois de adicionar uma camada New Relic Lambda, a extensão é habilitada e tem o envio de log desabilitado por padrão.

Se quiser ver o log de funções no New Relic, você precisará habilitar o envio de extensão do log de funções com uma variável de ambiente.

É importante observar que o log da função é apenas o log registrado pela função durante sua invocação. A extensão não enviará log de tempo de execução do Lambda como START, END e REPORT linhas.

Você pode escolher enviar dados somente para o CloudWatch ou como fallback. Para saber mais, consulte nossa documentação de fallback do CloudWatch.