Scaling statsd con múltiples servidores -- scale campo con scaling campo con statsd camp Relacionados El problema

scaling statsd with multiple servers


6
vote

problema

Español

Estoy diseñando una arquitectura donde usaremos estadsd y grafito. Entiendo cómo funciona el grafito y cómo un solo servidor Statsd podría comunicarse con él. Me pregunto cómo la arquitectura y la configuración funcionarían para escalar servidores de estadsd. ¿Tendría múltiples servidores de nodo statsd y luego un servidor de estadsd central presionando a grafito? Parece que no podía encontrar nada acerca de escalar estadsD y cualquier idea de cómo ser apreciado múltiples servidores de estadsd.

Original en ingles

I am laying out an architecture where we will be using statsd and graphite. I understand how graphite works and how a single statsd server could communicate with it. I am wondering how the architecture and set up would work for scaling out statsd servers. Would you have multiple node statsd servers and then one central statsd server pushing to graphite? I couldn't seem to find anything about scaling out statsd and any ideas of how to have multiple statsd servers would be appreciated.

        

Lista de respuestas

9
 
vote
vote
La mejor respuesta
 

Estoy tratando con el mismo problema en este momento. Obviamente, el equilibrio de carga ingenuo entre múltiples estadísticas, obviamente, no funciona porque las claves con el mismo nombre terminarían en diferentes estadísticas y, por lo tanto, se agregarían incorrectamente.

Pero hay un par de opciones para usar STATSD en un entorno que necesita escalar:

  • Utilice el muestreo del lado del cliente para las métricas de contador, como se describe en la documentación de Statsd (es decir, en lugar de enviar todos los eventos a estadsd, envíe solo cada 10º evento y haga que estadsd se multiplique por 10). El inconveniente es que necesita establecer manualmente una tasa de muestreo adecuada para cada una de sus métricas. Si muestra muy pocos valores, sus resultados serán inexactos. Si muestra demasiado, matará su instancia de estadística (única).

  • construir un equilibrador de carga personalizado que fragua por el nombre métrico a diferentes estadísticas, lo que eludió el problema de la agregación rota. Cada uno de ellos podría escribir directamente a grafito.

  • construir un cliente de estadsd que cuenta los eventos localmente y solo los envíe en conjunto a estadsd. Esto reduce en gran medida el tráfico que va a Statsd y también lo hace constante (siempre y cuando no agregue más servidores). Mientras el período con el que envíe los datos a STATSD sea mucho más pequeño que el propio período de descarga de STATSD, también debe obtener resultados similares de manera similar.

  • variación del último punto que he implementado con gran éxito en la producción : Use una primera capa de estadísticas múltiples (en mi caso local), que a su vez se agrega en una central Statsd, que luego habla con grafito. La primera capa de estadísticas tendría que tener un tiempo de descarga mucho más pequeño que el segundo. Para hacer esto, necesitará un backend statsd-to-statsd. Desde que enfrenté exactamente este problema, escribí uno que intenta ser lo más eficiente en la red como sea posible: https://github.com / juliusv / ne-statsd-backend

Como es, Lamentablemente, Statsd no está diseñado para escalar de una manera manejable (no, no veo ajustar las tasas de muestreo manualmente como "manejable"). Pero las soluciones anteriores deben ayudar si está atrapado con él.

 

I'm dealing with the same problem right now. Doing naive load-balancing between multiple statsds obviously doesn't work because keys with the same name would end up in different statsds and would thus be aggregated incorrectly.

But there are a couple of options for using statsd in an environment that needs to scale:

  • use client-side sampling for counter metrics, as described in the statsd documentation (i.e. instead of sending every event to statsd, send only every 10th event and make statsd multiply it by 10). The downside is that you need to manually set an appropriate sampling rate for each of your metrics. If you sample too few values, your results will be inaccurate. If you sample too much, you'll kill your (single) statsd instance.

  • build a custom load-balancer that shards by metric name to different statsds, thus circumventing the problem of broken aggregation. Each of those could write directly to Graphite.

  • build a statsd client that counts events locally and only sends them in aggregate to statsd. This greatly reduces the traffic going to statsd and also makes it constant (as long as you don't add more servers). As long as the period with which you send the data to statsd is much smaller than statsd's own flush period, you should also get similarly accurate results.

  • variation of the last point that I have implemented with great success in production: use a first layer of multiple (in my case local) statsds, which in turn all aggregate into one central statsd, which then talks to Graphite. The first layer of statsds would need to have a much smaller flush time than the second. To do this, you will need a statsd-to-statsd backend. Since I faced exactly this problem, I wrote one that tries to be as network-efficient as possible: https://github.com/juliusv/ne-statsd-backend

As it is, statsd was unfortunately not designed to scale in a manageable way (no, I don't see adjusting sampling rates manually as "manageable"). But the workarounds above should help if you are stuck with it.

 
 
 
 
3
 
vote

La mayoría de las implementaciones que vi su uso por métricas de servidor, como: <env>.applications.<app>.<server>.<metric>

Con este enfoque, puede tener instancias locales de estadsd en cada casilla, haga el trabajo UDP localmente, y deje que StatsD publique sus agregados a grafito.

Si no necesita realmente por métricas de servidor, tiene dos opciones:

  1. Métricas relacionadas con la combinación en la capa de visualización (por ejemplo: por Configurando graphiti para hacerlo )
  2. Utilice la agregación de carbono a Cuida de eso
 

Most of the implementations I saw use per server metrics, like: <env>.applications.<app>.<server>.<metric>

With this approach you can have local statsd instances on each box, do the UDP work locally, and let statsd publish its aggregates to graphite.

If you dont really need per server metrics, you have two choices:

  1. Combine related metrics in the visualization layer (e.g.: by configuring graphiti to do so)
  2. Use carbon aggregation to take care of that
 
 
1
 
vote

Si tiene acceso a un equilibrador de carga de hardware como un bigno de F5 (me imagino que hay implementaciones de software OSS que hacen esto) y que tengan el nombre de host de cada anfitrión en sus métricas (es decir, está contando cosas como "AppName .servername.foo.bar.baz "y agregándolos en el nivel de grafito) Puede usar el equilibrio de carga de afinidad de la dirección de origen: envía todo el tráfico desde una dirección de origen al mismo nodo de destino (dentro de un tiempo de espera razonable). Entonces, siempre y cuando cada nombre métrico provenga de un solo host de origen, esto logrará el resultado deseado.

 

If you have access to a hardware load balancer like a F5 BigIP (I'd imagine there are OSS software implementations that do this) and happen to have each host's hostname in your metrics (i.e. you're counting things like "appname.servername.foo.bar.baz" and aggregating them at the Graphite level) you can use source address affinity load balancing - it sends all traffic from one source address to the same destination node (within a reasonable timeout). So, as long as each metric name comes from only one source host, this will achieve the desired result.

 
 

Relacionados problema

4  Patrón de nombramiento en grafito y estadsd  ( Naming pattern in graphite and statsd ) 
Descripción del problema: Tengo módulo que hace lo siguiente. delete/folder delete/file move/folder move/file Esta aplicación se está ejecutando en múl...

8  Definición del comportamiento "global" en el trámite (duración de la tarea de medición)  ( Defining global behavior in gulp measuring task duration ) 
Estoy trabajando en movernos de ant a gulp , y como parte del esfuerzo que quiero escribir estadísticas de tiempo a grafito. Estamos haciendo esto en ant ...

21  Métricas de seguimiento Usando STATSD (a través de ETSY) y GRAFITE, el gráfico de grafito no parece estar gráficos todos los datos  ( Tracking metrics using statsd via etsy and graphite graphite graph doesnt se ) 
Tenemos una métrica que incrementamos cada vez que un usuario realiza una determinada acción en nuestro sitio web, pero los gráficos no parecen ser precisos. ...

2  ¿Entendiendo el grafito y cómo funciona? [cerrado]  ( Understanding graphite and how it works ) 
cerrado. Esta pregunta no cumple con pautas de desbordamiento de pila . Actualmente no está aceptando respuestas. ...

4  Uso correcto de los nombres métricos de grafito  ( Correct use of graphite metric names ) 
He construido una herramienta de análisis web y considera usar grafito. Esta es una herramienta muy básica con solo unas pocas dolimes interesantes, pero hay ...

2  Cómo monitorear AWS SQS con grafito - Grafana  ( How to monitor aws sqs with graphite grafana ) 
Tengo un montón de micro-servicios alojados en AWS. Estoy usando StatsD, Grafito y Grafana para monitorearlos. Ahora quiero expandirlo para monitorear las col...

3  ¿Hay algún problema con el uso de temporizadores de estadsD para los datos que no son temporizadores?  ( Is there an issue with using statsd timers for non timer data ) 
https://github.com/etsy/statsd/ BLOB / MASTER / DOCS / METRIC_TYPES.MD # TIMING "EstadsD figura existidos porcentidos, promedio (media), desviación estánd...

18  ¿Qué cliente estadsd debo usar para un proyecto Java / Grails?  ( Which statsd client should i use for a java grails project ) 
Estoy buscando agregar la recopilación de datos de STATSD a My Grails Solicitud y mirar a su alrededor en las bibliotecas y el código existentes me han dejado...

4  Filtro de métricas en grafito - ignorar la jerarquía (puntos)  ( Metrics filter in graphite ignore hierarchy dots ) 
¿Hay alguna forma de filtrar las métricas en grafito mientras ignorando la jerarquía? Por ejemplo: Digamos que tengo las siguientes métricas: stats_count...

7  ¿Cómo analizar la tasa de golpe de la tecla Memcache con grafito?  ( How to analyze memcache key hit rate with graphite ) 
Tengo una aplicación de rieles que utiliza el almacenamiento en caché extensivamente y quiero saber la tarifa de éxito de caché para diferentes lugares en la ...




© 2022 respuesta.top Reservados todos los derechos. Centro de preguntas y respuestas reservados todos los derechos