Monitoramento vLLM

Editar online

vLLM é uma estrutura de código aberto para otimizar e acelerar a inferência de grandes modelos de linguagem (LLM). Monitore sua infraestrutura do vLLM com o Instana, coletando métricas de desempenho para obter visibilidade sobre a utilização de recursos, a taxa de transferência, a latência e o estado geral do sistema em suas implantações de LLM.

Pré-requisitos

  • Python 3.10 ou posterior

  • vLLM 0.6.3.post1 ou posterior

  • Acesso a um agente ou backend d Instana

Configurando Variáveis de Ambiente

Configure seu ambiente para exportar rastreamentos para Instana usando o modo com agente ou o modo sem agente.

Modo do agente

Exportar registros por meio de um agente do Instana :

export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT="http://<instana-agent-host>:4317"
export OTEL_SERVICE_NAME="<your-service-name>"

Modo sem agente

Exporte os traços diretamente para o backend do Instana :

export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT="https://<otlp-acceptor-domain>:4317"
export OTEL_EXPORTER_OTLP_HEADERS="x-instana-key=<agent-key>"
export OTEL_SERVICE_NAME="<your-service-name>"

Para terminais sem o ` TLS `, defina:

export OTEL_EXPORTER_OTLP_INSECURE=true
Dica:

Para obter informações sobre os pontos de extremidade do backend ` Instana `, consulte os pontos de extremidade do backend `otlp-acceptor` do ` Instana `.

Instalando dependências

  1. Verifique a versão do Python :

    python3 -V

  2. (Opcional) Crie um ambiente virtual:

    pip3 install virtualenv
virtualenv vllm-env
source vllm-env/bin/activate

  3. Instalar o vLLM:

    pip3 install vllm==0.6.3.post1

    Para métodos alternativos de instalação, consulte a documentação do vLLM.

  4. Instale os pacotes d OpenTelemetry :
     
pip3 install
  'opentelemetry-sdk>=1.26.0,<1.27.0' 
  'opentelemetry-api>=1.26.0,<1.27.0' 
  'opentelemetry-exporter-otlp>=1.26.0,<1.27.0' 
  'opentelemetry-semantic-conventions-ai>=0.4.1,<0.5.0'

Implementação de monitoramento em aplicações do tipo “ vLLM ”

Iniciando o servidor do vLLM

Implemente o ` vLLM ` como um servidor independente com pontos de extremidade ` API `. Se você quiser dar uma olhada no aplicativo cliente, pode experimentar a implementação de exemplo fornecida abaixo.

Inicie o servidor do ` vLLM `:

vllm serve ibm-granite/granite-3.0-2b-instruct --otlp-traces-endpoint="$OTEL_EXPORTER_OTLP_TRACES_ENDPOINT"

Criação de um aplicativo cliente

Crie um aplicativo cliente para enviar solicitações ao servidor vLLM :

import requests
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
from opentelemetry.trace import SpanKind, set_tracer_provider
from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator

# Configure OpenTelemetry
trace_provider = TracerProvider()
set_tracer_provider(trace_provider)
trace_provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter()))
trace_provider.add_span_processor(BatchSpanProcessor(ConsoleSpanExporter()))

tracer = trace_provider.get_tracer("vllm-client")

vllm_url = "http://localhost:8000/v1/completions"
with tracer.start_as_current_span("client-span", kind=SpanKind.CLIENT) as span:
  prompt = "San Francisco is a"
  span.set_attribute("prompt", prompt)
  headers = {}
  TraceContextTextMapPropagator().inject(headers)
  payload = {
    "model": "ibm-granite/granite-3.0-2b-instruct",
    "prompt": prompt,
    "max_tokens": 10,
    "n": 1,
    "best_of": 1,
    "use_beam_search": "false",
    "temperature": 0.0,
  }
  response = requests.post(vllm_url, headers=headers, json=payload)
  print(response)
Figura 1. Visão geral do rastreamento com o servidor
Visão geral do rastreamento com o servidor

Visualização de traços no Instana

Após executar sua aplicação, os dados aparecerão no painel de observabilidade da Gen AI do Instana. Você pode analisar chamadas por aplicativo, serviço e ponto de extremidade, além de visualizar registros juntamente com informações de rastreamento.

Para obter mais detalhes sobre como visualizar e analisar traços, consulte Visualização de dados de telemetria.

Coleta de métricas do vLLM

Você pode coletar métricas do vLLM usando uma das seguintes opções:

Opção 1: Utilização de um coletor de dados do OTel para o vLLM (ODCV)

O ODCV coleta métricas do OpenTelemetry a partir do vLLM com base em convenções semânticas predefinidas.

Pré-requisitos

  • Java SDK 11 ou posterior

Verifique a instalação:

java -version

Procedimento

  1. Baixe o pacote ODCV mais recente:

    wget https://github.com/instana/otel-dc/releases/download/v1.0.7/otel-dc-vllm-1.0.0.tar

  2. Extraia o pacote:

    tar xf otel-dc-vllm-1.0.0.tar
cd otel-dc-vllm-1.0.0

  3. Configurar config/config.yaml:

    vi config/config.yaml

    Atualize estes campos:

    • otel.agentless.mode: Modo de conexão (true para sem agente, false para com agente)

    • otel.backend.url: Endpoint gRPC para o backend ou agente Instana

    • callback.interval: Intervalo de envio de dados em segundos

    • otel.service.name: Nome do coletor de dados

    • otel.vllm.metrics.url: Endpoint de métricas do servidor vLLM (utilize-o https se o TLS estiver ativado)

    Para o modo sem agente: (otel.agentless.mode: true):

    Para o modo agente: (otel.agentless.mode: false):

    • otel.backend.url: Endpoint do agente Instana (por exemplo, http://<instana-agent-host>:4317)

  4. (Opcional) Configurar o registro de logs:

    vi config/logging.properties
  5. Execute o Coletor de Dados:
    nohup ./bin/otel-dc-vllm >/dev/null 2>&1 &

    Como alternativa, use tmux ou screen para execução em segundo plano.

Opção 2: Utilização do coletor de dados de código aberto OpenTelemetry

Você pode encaminhar dados do ` OpenTelemetry ` do ` vLLM ` para um agente do ` Instana ` ou um backend do ` Instana ` usando o coletor ` OpenTelemetry `.

Você pode usar um dos seguintes coletores do OpenTelemetry :

  • Instana Distribuição do coletor OpenTelemetry ( IDOT ) — Uma distribuição pré-configurada e otimizada que simplifica a configuração do monitoramento do vLLM. Para mais informações, consulte IDOT e o projeto OpenTelemetry

  • Um coletor de dados de telemetria de código aberto ( OpenTelemetry ) — O componente central do ecossistema OpenTelemetry, oferecendo funções independentes de fornecedores para a coleta, o processamento e a exportação de dados de telemetria. Para implantações personalizadas ou ambientes em que o IDOT não está disponível. Para obter mais informações, consulte o coletor OpenTelemetry.

Instana suporta os seguintes modelos para coleta de dados:

  • Modelo de agente - Os dados são enviados primeiro ao agente Instana, e o agente auxilia na agregação dos dados e no envio para o backend Instana.

  • Modelo sem agente - Os dados são enviados diretamente para o backend do Instana, sem passar pelo agente.

Envio de dados de telemetria para um agente do Instana (modelo de agente)

O trecho a seguir mostra uma configuração típica do coletor OpenTelemetry para encaminhar dados de telemetria a um agente local no host Instana, utilizando o protocolo OTLP / HTTP. Crie um arquivo ` YAML `, como ` config.yaml `, da seguinte maneira:

receivers:
  otlp/receiver:
    protocols:
      grpc:
  prometheus:
    config:
      scrape_configs:
        - job_name: 'prometheus-scrape'
          scrape_interval: 10s
          static_configs:
            - targets:
              - "$(PROMETHEUS_METRICS_ENDPOINT)"
          metrics_path: '/metrics'
processors:
  batch: {}
  resource:
    attributes:
      - key: service.name
        value: vllm
        action: insert
      - key: service.namespace
        value: genai
        action: insert
      - key: service.instance.id
        value: <vllm-host>
        action: insert
      - key: server.address
        value: <vllm-host-address>
        action: insert
      - key: server.port
        value: "8000"
        action: insert
      - key: vllm.entity.type
        value: vllm
        action: insert
      - key: INSTANA_PLUGIN
        value: vllm
        action: insert

exporters:
  otlphttp:
    endpoint: "http://$(INSTANA_AGENT_HOST):4318"
    tls:
      insecure: true

service:
  pipelines:
    metrics/prometheus:
      receivers: [prometheus]
      processors: [resource, batch]
      exporters: [otlphttp]
Nota:

PROMETHEUS_METRICS_ENDPOINT representa o endpoint do qual as métricas d vLLM serão extraídas. Por exemplo, o valor é 9.60.233.77:8000.

O exemplo a seguir mostra uma configuração típica do coletor OpenTelemetry para o encaminhamento de dados de telemetria a um agente local do host Instana, utilizando o protocolo OTLP /grpc.

exporters:
  otlp:
    endpoint: "$(INSTANA_AGENT_HOST):4317"
    tls:
      insecure: true

  • Defina o campo PROMETHEUS_METRICS_ENDPOINT com o endpoint do exportador de métricas vLLM.

  • Defina o campo INSTANA_AGENT_HOST com o endereço IP ou o nome do host do agente do Instana ao qual deseja se conectar.

  • Instana utiliza números de porta padrão d OTLP, como 4317 para OTLP/gRPC e 4318 para OTLP / HTTP.

Depois de concluir todas as alterações de configuração no arquivo ` config.yaml `, execute o seguinte comando para usar o coletor ` OpenTelemetry `:

docker run -d -p 4317:4317 -v $(pwd)/config.yaml:/etc/otelcol-contrib/config.yaml otel/opentelemetry-collector-contrib:latest

Envio de dados de telemetria para o backend do Instana (modelo sem agente)

Para encaminhar dados do ` OpenTelemetry ` para o backend do ` Instana ` usando o coletor ` OpenTelemetry `, siga estas etapas:

  1. Crie um arquivo ` YAML `, como ` config.yaml `, da mesma forma que na seção anterior. Altere o endpoint de Instana (endpoint do agente) para Instana (endpoint do backend). Os pontos de extremidade especiais do componente backend otlp-acceptor são utilizados quando os dados OpenTelemetry são enviados. O backend do Instana requer uma chave de agente do Instana para validação.

    exporters:
  otlp:
    endpoint: INSTANA_OTLP_GRPC_BACKEND:4317
    headers:
      x-instana-key: xxxxxxx
      x-instana-host: xxxx
    Nota:

    • Defina o INSTANA_OTLP_GRPC_BACKEND campo com o nome de domínio correto do otlp-acceptor componente do backend do Instana. otlp-acceptorPara obter mais informações sobre o endpoint do backend Instana, consulte Endpoints do backend otlp-acceptor do Instana auto-hospedado ou Endpoints do backend otlp-acceptor do SaaS Instana

    • Defina o x-instana-key campo com a chave do agente do Instana para direcionar para o backend Instana. Para encontrar sua chave de agente, clique em “Mais” > “Agentes” na barra de navegação da interface do usuário do Instana e, em seguida, clique em “Instalar agentes” > “ Windows ”.

    • host.idDefina o x-instana-host campo com o ID do host caso nenhum atributo de recurso, faas.id, ou device.id esteja definido em sua aplicação ou sistema.

    • Instana utiliza números de porta padrão d OTLP, como 4317 para OTLP/gRPC e 4318 para OTLP/HTTP. A porta 443 também é compatível com OTLP/HTTP.

  2. Depois de concluir todas as alterações de configuração no config.yaml arquivo, execute o seguinte comando para usar o coletor OpenTelemetry :

    docker run -d -p 4317:4317 -v $(pwd)/config.yaml:/etc/otelcol-contrib/config.yaml otel/opentelemetry-collector-contrib:latest

Visualizando métricas do vLLM no Instana

Após configurar a coleta de métricas usando qualquer uma das opções:

  1. Na interface do usuário do Instana, acesse Infraestrutura > Analisar infraestrutura

  2. Selecione “ OTel ” e “ vLLMonitor ” entre os tipos de entidade

  3. Clique em uma instância do OTel vLLMonitor para visualizar seu painel

Figura 2. Métricas do vLLM
vLLM métricas

Resolução de problemas

Informações sobre como solucionar erros de handshake no protocolo SSL.

SSL erros de handshake

Se você encontrar erros do tipo “ SSL ”, tais como:

Handshake failed with fatal error SSL_ERROR_SSL: error:100000f7:SSL routines:OPENSSL_internal:WRONG_VERSION_NUMBER.

Defina as seguintes opções para exportar dados sem o ` TLS `:

export OTEL_EXPORTER_OTLP_INSECURE=true

Próximas etapas

  • Configurar alertas para métricas de desempenho do ` vLLM `

  • Explore a correlação de rastreamento entre o cliente e o servidor

  • Consulte OpenTelemetry para configurações avançadas

  • Monitore o vLLM em Kubernetes ou OpenShift, implantando um coletor do OTel para coletar métricas de pods