ProHoster > blog > amministrazione > Monitoraggio dei microservizi Flask con Prometheus

Monitoraggio dei microservizi Flask con Prometheus

Un paio di righe di codice e la tua applicazione genera metriche, wow!

Per capire come funziona prometheus_borraccia_esportatore è sufficiente un minimo esempio:

from flask import Flask
from prometheus_flask_exporter import PrometheusMetrics

app = Flask(__name__)
metrics = PrometheusMetrics(app)

@app.route('/')
def main():
    return 'OK'

Questo è tutto ciò che ti serve per iniziare! Aggiungendo un'importazione e una riga per l'inizializzazione PrometheusMetrica, otterrai le metriche durata della richiesta и contatori delle richieste, visualizzato all'endpoint /metrica l'applicazione Flask con cui è registrato, nonché tutte le metriche predefinite ottenute dalla base Libreria client Prometheus.

ожете найти esempio facile da usare nel repository GitHub che esegue l'istanza Prometeo и graminacee insieme a un'applicazione demo per generare metriche che assomiglieranno a questa:

Monitoraggio dei microservizi Flask con Prometheus

Troverai anche un elenco di indicatori in README esempi visualizzati nel dashboard, insieme alle query Prometheus che popolano i dashboard.

registrazione

Ci sono molte opzioni di configurazione nella libreria, guarda README esempi di progetti con una breve spiegazione.

La configurazione di base è mostrata sopra. Basta creare un'istanza PrometheusMetrica, chiamiamolo metrica, quindi utilizzalo per definire le metriche aggiuntive che desideri raccogliere decorando le funzioni:

  • @metrics.counter(..)

  • @metrics.gauge(..)

  • @metrics.summary(..)

  • @metrics.histogram(..)

I contatori contano le chiamate e altri raccolgono metriche in base alla durata di tali chiamate. È possibile definire etichette per ognuno di questi, potenzialmente utilizzando le proprietà di richiesta o di risposta. Per esempio:

from flask import Flask, request
from prometheus_flask_exporter import PrometheusMetrics

app = Flask(__name__)

# group by endpoint rather than path
metrics = PrometheusMetrics(app, group_by='endpoint')

@app.route('/collection/:collection_id/item/:item_id')
@metrics.counter(
    'cnt_collection', 'Number of invocations per collection', labels={
        'collection': lambda: request.view_args['collection_id'],
        'status': lambda resp: resp.status_code
    })
def get_item_from_collection(collection_id, item_id):
    pass

Nell'esempio precedente, facendo clic sull'endpoint /collection/10002/item/76 farà aumentare il contatore, ad esempio cnt_collection{raccolta = "10002", stato = "200"}, inoltre otterrai i parametri predefiniti (per ciascun endpoint in questo esempio) dalla libreria predefinita:

  • flask_http_request_duration_seconds — Durata della richiesta HTTP in secondi per tutte le richieste Flask per metodo, percorso e stato

  • flask_http_request_total — Numero totale di richieste HTTP per metodi e stati

Sono disponibili opzioni per ignorare il monitoraggio di endpoint specifici, registrare parametri predefiniti aggiuntivi o ignorare quelli elencati sopra oppure applicare la stessa metrica personalizzata a più endpoint. Guardare README progetto per vedere cosa è disponibile.

app = Flask(__name__)
metrics = PrometheusMetrics(app)

@app.route('/')
def main():
    pass  # requests tracked by default

@app.route('/skip')
@metrics.do_not_track()
def skip():
    pass  # default metrics are not collected

# custom metric to be applied to multiple endpoints
common_counter = metrics.counter(
    'by_endpoint_counter', 'Request count by endpoints',
    labels={'endpoint': lambda: request.endpoint}
)

@app.route('/common/one')
@common_counter
def endpoint_one():
    pass  # tracked by the custom and the default metrics

@app.route('/common/two')
@common_counter
def endpoint_two():
    pass  # also tracked by the custom and the default metrics

# register additional default metrics
metrics.register_default(
    metrics.counter(
        'by_path_counter', 'Request count by request paths',
        labels={'path': lambda: request.path}
    )
)

La libreria dispone di comode estensioni per le librerie multiprocessore più diffuse come uWSGI e Gunicorn. Puoi anche trovare piccoli esempi di casi d'uso mirati, incluso il multiprocessing.

Raccolta delle metriche

Come accennato in precedenza, la libreria fornisce un endpoint per impostazione predefinita /metrica in un'applicazione Flask, che può fungere da destinazione per Costruttore di Prometeo.

Nell'esempio della dashboard sopra, potresti indirizzare il tuo Prometheus a un'applicazione Flask con impostazioni predefinite con questa configurazione:

scrape_configs:
  - job_name: 'example'

    dns_sd_configs:
      - names: ['app']
        port: 5000
        type: A
        refresh_interval: 5s

Vedi l'esempio completo su Repository GitHub. Ciò presuppone che Prometheus possa trovare le istanze dell'applicazione Flask su http://app:5000/metrics, dove il nome del dominio dell'applicazione potrebbe potenzialmente risolversi in più indirizzi IP, ad esempio durante l'esecuzione kubernetes o Sciame portuale.

Se esporre l'endpoint delle metriche in questo modo non ti soddisfa, magari perché non vuoi consentirne l'accesso esterno, puoi facilmente disabilitarlo passando percorso=Nessuno durante la creazione di un'istanza PrometheusMetrica.

from flask import Flask, request
from prometheus_flask_exporter import PrometheusMetrics

app = Flask(__name__)
metrics = PrometheusMetrics(app, path=None)

...

metrics.start_http_server(5099)

Quindi puoi usare start_http_server(porta)per aprire questo endpoint su una porta HTTP diversa, 5099 nell'esempio sopra. In alternativa, se sei soddisfatto che l'endpoint si trovi nella stessa applicazione Flask, ma devi modificare il suo percorso da /metrica, puoi passare un altro URI come parametro del percorso oppure utilizzare registro_endpoint(..)per installarlo in seguito.

riferimenti

Se decidi di provarlo, sentiti libero di aprire un problema su GitHub o lasciare i tuoi commenti, feedback e suggerimenti!

Grazie!

Fonte: habr.com

Aggiungi un commento