Este documento foi traduzido usando tecnologia de tradução automática de máquina. Sempre trabalhamos para apresentar traduções precisas, mas não oferecemos nenhuma garantia em relação à integridade, precisão ou confiabilidade do conteúdo traduzido. Em caso de qualquer discrepância, a versão original em inglês prevalecerá e constituirá o texto official.

Introdução ao AWS Lambda

Configurando o monitoramento para uma ou mais funções AWS Lambda:

  • A(s) função(ões) AWS Lambda monitorada(s) (instrumentada(s) usando Open Telemetry)

  • O coletor Open Telemetry

  • SUSE Observability ou SUSE Cloud Observability

Instrumentação AWS Lambda com Open Telemetry com o coletor Open Telemetry rodando no Kubernetes

O coletor Open Telemetry

Para uma configuração de produção, é fortemente recomendado instalar o coletor, pois ele permite que seu serviço descarregue dados rapidamente e o coletor pode cuidar de manuseios adicionais como tentativas, agrupamento, criptografia ou até mesmo filtragem de dados sensíveis.

Instale o coletor OTel (Open Telemetry), neste exemplo usamos um cluster Kubernetes para executá-lo próximo às funções Lambda. Uma configuração semelhante pode ser feita usando um coletor instalado em uma máquina virtual. A configuração utilizada aqui atua apenas como um proxy seguro para descarregar dados rapidamente das funções Lambda e roda dentro de uma infraestrutura de rede confiável.

Criar um Token de Serviço

Há duas maneiras de criar um token de serviço:

  • SUSE Observability UI - abra o menu principal clicando no canto superior esquerdo da tela e vá para StackPacks > Open Telemetry. Se você ainda não fez isso, clique no botão INSTALL. Clique no botão CREATE NEW SERVICE TOKEN e copie o valor para a sua área de transferência.

  • SUSE Observability CLI - veja Gerenciar tokens de serviço

O valor do token de serviço deve ser usado onde as instruções abaixo mencionam <SERVICE_TOKEN>.

Crie o namespace e um segredo para o token de serviço

Instale no namespace open-telemetry e use o token de serviço:

kubectl create namespace open-telemetry
kubectl create secret generic open-telemetry-collector \
    --namespace open-telemetry \
    --from-literal=API_KEY='<SERVICE_TOKEN>'

Configure e instale o coletor

Instalamos o coletor com um gráfico Helm fornecido pelo projeto Open Telemetry. Certifique-se de que você tenha o repositório de gráficos Helm do Open Telemetry configurado:

helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts

Crie um arquivo de valores otel-collector.yaml para o gráfico Helm. Aqui está um bom ponto de partida para uso com SUSE Observability, substitua <otlp-suse-observability-endpoint:port> pelo seu endpoint OTLP (veja API OTLP para seu endpoint) e insira o nome do seu cluster Kubernetes em vez de <your-cluster-name>. Ao usar a configuração de ingress, também certifique-se de inserir seu próprio nome de domínio e o segredo do certificado TLS correspondente nos locais marcados.

otel-collector.yaml
mode: deployment
presets:
  kubernetesAttributes:
    enabled: true
    # You can also configure the preset to add all the associated pod's labels and annotations to you telemetry.
    # The label/annotation name will become the resource attribute's key.
    extractAllPodLabels: true
extraEnvsFrom:
  - secretRef:
      name: open-telemetry-collector
image:
  repository: "ghcr.io/open-telemetry/opentelemetry-collector-releases/opentelemetry-collector-k8s"

config:
  receivers:
    otlp:
      protocols:
        grpc:
          endpoint: 0.0.0.0:4317
        http:
          endpoint: 0.0.0.0:4318
  extensions:
    # Use the API key from the env for authentication
    bearertokenauth:
      scheme: SUSEObservability
      token: "${env:API_KEY}"
  exporters:
    otlp:
      auth:
        authenticator: bearertokenauth
      # Put in your own otlp endpoint, for example otlp-suse-observability.my.company.com:443
      endpoint: <otlp-suse-observability-endpoint:port>

  service:
    extensions: [health_check, bearertokenauth]
    pipelines:
      traces:
        receivers: [otlp]
        processors: [batch]
        exporters: [otlp]
      metrics:
        receivers: [otlp]
        processors: [batch]
        exporters: [otlp]
      logs:
        receivers: [otlp]
        processors: [batch]
        exporters: [otlp]

ingress:
  enabled: true
  annotations:
    kubernetes.io/ingress.class: ingress-traefik-external
    traefik.ingress.kubernetes.io/ingress.class: ingress-traefik-external
    traefik.ingress.kubernetes.io/backend-protocol: GRPC
    # "12.34.56.78/32" IP address of NatGateway in the VPC where the otel data is originating from
    #  traefik.ingress.kubernetes.io/whitelist-source-range: "12.34.56.78/32"
  hosts:
    - host: "otlp-collector-proxy.<your-domain>"
      paths:
        - path: /
          pathType: ImplementationSpecific
          port: 4317
  tls:
    - secretName: <secret-for-tls-certificate>
      hosts:
        - "otlp-collector-proxy.<your-domain>"

# Instead of ingress:

# Alternative 1, load balancer service
#service:
#  type: LoadBalancer
#  loadBalancerSourceRanges: 12.34.56.78/32 # The IP address of NatGateway in the VPC for the lambda functions

# Alternative 2, node port service
#service:
#  type: NodePort
#ports:
#  otlp:
#    nodePort: 30317

Agora instale o coletor, usando o arquivo de configuração:

helm upgrade --install opentelemetry-collector open-telemetry/opentelemetry-collector \
  --values otel-collector.yaml \
  --namespace open-telemetry

Certifique-se de que o coletor proxy seja acessível pelas funções Lambda, tendo o ingress publicamente acessível ou tendo o IP do coletor na mesma VPC que as funções Lambda. É recomendável usar uma lista de permissões de intervalo de origem para filtrar dados de fontes não confiáveis e/ou desconhecidas (veja o comentário no yaml). Ao lado da configuração de ingress, também é possível expor o coletor para as funções Lambda via:

  • um serviço LoadBalancer que restringe o acesso limitando os intervalos de origem, veja "Alternativa 1".

  • um serviço NodePort para o coletor, veja "Alternativa 2".

O coletor oferece muito mais opções de configuração de receptores, processadores e exportadores; para mais detalhes, veja nossa página do coletor. Para uso em produção, frequentemente grandes quantidades de spans são geradas e você vai querer começar a configurar amostragem.

Instrumentar uma função Lambda

Open Telemetry suporta a instrumentação de funções Lambda em várias linguagens usando camadas Lambda. A configuração dessas camadas Lambda deve usar o endereço do coletor da etapa anterior para enviar os dados. Para instrumentar uma função Lambda Node.js, siga nossas instruções detalhadas aqui. Para instrumentar outras linguagens, aplique a mesma configuração que para Node.js, mas use uma das outras camadas Lambda do Open Telemetry.

Veja os resultados

Vá para o SUSE Observability e certifique-se de que o Stackpack Open Telemetry está instalado (via o menu principal -> Stackpacks).

Após um curto período e se suas funções Lambda estiverem recebendo algum tráfego, você deve conseguir encontrá-las sob seus nomes de serviço nas visões de Open Telemetry -> serviços e instâncias de serviço. Os rastreamentos aparecerão no explorador de rastreamentos e na perspectiva de rastreamentos para os componentes de serviço e instância de serviço. Métricas de span e métricas específicas de linguagem (se disponíveis) estarão disponíveis na perspectiva de métricas para os componentes.

Próximas etapas

Você pode adicionar novos gráficos aos componentes, por exemplo, o serviço ou a instância de serviço, para seu aplicativo, seguindo nosso guia. Também é possível criar novos monitores usando as métricas e configurar notificações para ser notificado quando seu aplicativo não estiver disponível ou tiver problemas de desempenho.

Mais informações