{"id":1443,"date":"2020-05-29T12:50:29","date_gmt":"2020-05-29T10:50:29","guid":{"rendered":"https:\/\/blog.besharp.it\/?p=1443"},"modified":"2021-03-17T15:18:09","modified_gmt":"2021-03-17T14:18:09","slug":"parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service","status":"publish","type":"post","link":"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/","title":{"rendered":"Parte II: Best practice per il logging su Python e come integrarsi con la dashboard di Kibana tramite Amazon Kinesis Data Firehose e Amazon Elasticsearch Service"},"content":{"rendered":"

In questa seconda parte del nostro viaggio alla scoperta dei segreti e delle best practice del logging in Python (se vi siete persi la prima parte, eccola qui!<\/a>) si far\u00e0 un passo ulteriore: gestire pi\u00f9 istanze applicative (e quindi pi\u00f9 stream di log), cosa piuttosto comune in scenari riguardanti progetti cloud, al fine di aggregare i log usando Amazon Kinesis Data Firehose, Amazon ElasticSearch Service e Kibana. Incominciamo!<\/span><\/p>\n

E\u2019 il momento di aggregare i log!<\/span><\/h2>\n

Nei casi in cui si voglia monitorare un’applicazione complessa, sforzarsi di raccogliere log distribuiti per comprendere cosa \u00e8 andato storto con il codice non \u00e8 un’idea particolarmente praticabile.<\/span><\/p>\n

Supponiamo che si abbia implementato un’API REST serverless tramite AWS API Gateway integrata via proxy con AWS Lambda Functions, scritta in Python, per ciascuno degli endpoint che si ha definito. Dato ci\u00f2 che abbiamo gi\u00e0 trattato in precedenza, in questo caso i log verranno presumibilmente scritti nei flussi di AWS CloudWatch tramite StreamHandler.<\/span><\/p>\n

E se invece di cercare i record di log all’interno dei flussi di log di CloudWatch, si desiderasse analizzarli da una dashboard centralizzata? Bene, in questo caso la risposta si chiama stack EKK (Amazon <\/span>E<\/b>lasticsearch Service, Amazon <\/span>K<\/b>inesis Data Firehose e <\/span>K<\/b>ibana).<\/span><\/p>\n

Prima di entrare nei dettagli della configurazione dello stack, introduciamo il ruolo di ciascuno degli attori dello stack. Quella che segue \u00e8 solo un’introduzione ai servizi utilizzati per questa soluzione di log, ricerca e analisi. Se si desiderasse ottenere maggiori informazioni su ciascuno dei servizi utilizzati, invitiamo a consultare la documentazione a loro dedicata.<\/span><\/p>\n

Attori dello stack EKK<\/span><\/h2>\n

Amazon Elasticsearch<\/b> Service \u00e8 un servizio gestito che consente di distribuire, gestire e ridimensionare un cluster Elasticsearch nel proprio account AWS. Fornisce un motore di ricerca e analisi che sfruttabile per monitorare i log della propria applicazione in tempo reale.<\/span><\/p>\n

Amazon Elasticsearch Service ha un’integrazione nativa con Kibana. Kibana \u00e8 uno strumento che offre una dashboard facile da usare in cui \u00e8 possibile monitorare ed eseguire il debug dell’applicazione in modo centralizzato.<\/span><\/p>\n

Amazon Kinesis Data Firehose<\/b> \u00e8 il servizio che funge da ponte tra i generatori di log e il cluster Elasticsearch. Kinesis Data Firehose consente di caricare i dati di streaming su uno o pi\u00f9 target specifici. Nella soluzione proposta in questo articolo, <\/span>Kinesis Data Firehose<\/b> viene utilizzato per lo streaming dei record di log prodotti da componenti dell’applicazione diversi e distribuiti su un cluster Elasticsearch e su un bucket S3, entrambi ospitati su un account AWS. Il bucket S3 viene utilizzato come backup dei record di registro e pu\u00f2 essere utilizzato per recuperare dati storici.<\/span><\/p>\n

Per quanto riguarda l’ecosistema Python, si pu\u00f2 fare affidamento sull’<\/span>SDK di AWS boto3<\/b> per trasmettere in streaming i registri locali direttamente a un delivery stream di Kinesis Data Firehose. Combinando il modulo di registrazione di Python con l’SDK di boto3, si pu\u00f2 eseguire lo streaming dei propri log su Kinesis Data Firehose. Nella sezione successiva vedremo come implementare il gestore di un modulo di log Python che caricher\u00e0 una versione JSON dei record di log in un delivery stream di Kinesis Data Firehose.<\/span><\/p>\n

Estendere il modulo di Logging di Python<\/span><\/h2>\n

Grazie alla natura estensibile del modulo di logging di Python, \u00e8 possibile implementare un handler personalizzato che soddisfi le nostre esigenze. In questa sezione illustreremo come implementare uno StreamHandler che trasmetta i dati di log a un delivery stream di Kinesis Data Firehose.<\/span><\/p>\n

Ecco l’implementazione:<\/span><\/p>\n

import boto3\r\nimport logging\r\n\r\n\r\nclass KinesisFirehoseDeliveryStreamHandler(logging.StreamHandler):\r\n\r\n   def __init__(self):\r\n       # By default, logging.StreamHandler uses sys.stderr if stream parameter is not specified\r\n       logging.StreamHandler.__init__(self)\r\n\r\n       self.__firehose = None\r\n       self.__stream_buffer = []\r\n\r\n       try:\r\n           self.__firehose = boto3.client('firehose')\r\n       except Exception:\r\n           print('Firehose client initialization failed.')\r\n\r\n       self.__delivery_stream_name = \"logging-test\"\r\n\r\n   def emit(self, record):\r\n       try:\r\n           msg = self.format(record)\r\n\r\n           if self.__firehose:\r\n               self.__stream_buffer.append({\r\n                   'Data': msg.encode(encoding=\"UTF-8\", errors=\"strict\")\r\n               })\r\n           else:\r\n               stream = self.stream\r\n               stream.write(msg)\r\n               stream.write(self.terminator)\r\n\r\n           self.flush()\r\n       except Exception:\r\n           self.handleError(record)\r\n\r\n   def flush(self):\r\n       self.acquire()\r\n\r\n       try:\r\n           if self.__firehose and self.__stream_buffer:\r\n               self.__firehose.put_record_batch(\r\n                   DeliveryStreamName=self.__delivery_stream_name,\r\n                   Records=self.__stream_buffer\r\n               )\r\n\r\n               self.__stream_buffer.clear()\r\n       except Exception as e:\r\n           print(\"An error occurred during flush operation.\")\r\n           print(f\"Exception: {e}\")\r\n           print(f\"Stream buffer: {self.__stream_buffer}\")\r\n       finally:\r\n           if self.stream and hasattr(self.stream, \"flush\"):\r\n               self.stream.flush()\r\n\r\n           self.release()\r\n<\/pre>\n
Come si pu\u00f2 notare, andando sullo specifico, l\u2019esempio mostra una classe, KinesisFirehoseDeliveryStreamHandler, che eredita il comportamento nativo della classe StreamHandler. I metodi di StreamHandler modificati per questo esempio sono emit e flush.
\nIl metodo emit \u00e8 responsabile dell’invocazione del metodo di format, dell’aggiunta di record di log allo stream e del metodo di flush. La modalit\u00e0 di formattazione dei dati di log dipende dal tipo di formattatore configurato per il gestore. Indipendentemente dalla modalit\u00e0 di formattazione, i dati di log verranno aggiunti all’array __stream_buffer o, nel caso in cui qualcosa sia andato storto durante l’inizializzazione del client Firehose, al flusso predefinito, ovvero sys.stderr.<\/p>\n
Il metodo flush \u00e8 responsabile dello streaming dei dati direttamente nel delivery stream di Kinesis Data Firehose attraverso l’API put_record_batch. Una volta che i record vengono trasmessi in streaming sul Cloud, lo _stream_buffer locale verr\u00e0 cancellato. L’ultimo passaggio del metodo flush consiste nel flushing dello stream di default.<\/p>\n
Questa implementazione \u00e8 puramente illustrativa ma cionondimeno solida per cui ci si senta liberi di copiare e personalizzare lo snippet in base alle proprie esigenze specifiche.<\/p>\n
Dopo aver incluso KinesisFirehoseDeliveryStreamHandler nella propria codebase, si deve poi aggiungerlo alla configurazione dei logger. Vediamo come cambia la configurazione del dizionario precedente nell\u2019introdurre il nuovo gestore.<\/p>\n
config = {\r\n  \"version\": 1,\r\n  \"disable_existing_loggers\": False,\r\n  \"formatters\": {\r\n      \"standard\": {\r\n          \"format\": \"%(asctime)s %(name)s %(levelname)s %(message)s\",\r\n          \"datefmt\": \"%Y-%m-%dT%H:%M:%S%z\",\r\n      },\r\n      \"json\": {\r\n          \"format\": \"%(asctime)s %(name)s %(levelname)s %(message)s\",\r\n          \"datefmt\": \"%Y-%m-%dT%H:%M:%S%z\",\r\n          \"class\": \"pythonjsonlogger.jsonlogger.JsonFormatter\"\r\n      }\r\n  },\r\n  \"handlers\": {\r\n      \"standard\": {\r\n          \"class\": \"logging.StreamHandler\",\r\n          \"formatter\": \"json\"\r\n      },\r\n      \"kinesis\": {\r\n          \"class\": \"KinesisFirehoseDeliveryStreamHandler.KinesisFirehoseDeliveryStreamHandler\",\r\n          \"formatter\": \"json\"\r\n      }\r\n  },\r\n  \"loggers\": {\r\n      \"\": {\r\n          \"handlers\": [\"standard\", \"kinesis\"],\r\n          \"level\": logging.INFO\r\n      }\r\n  }\r\n}\r\n<\/pre>\n
Per includere il nuovo handler personalizzato nella propria configurazione, \u00e8 sufficiente aggiungere una voce “kinesis” al dizionario “handlers” e una voce “kinesis” nell’array “handlers” del logger di root.<\/p>\n
Nella voce “kinesis” del dizionario “handlers” dovremmo specificare la classe del handler personalizzato e il formatter utilizzato da quest\u2019ultimo per formattare i record di log.<\/p>\n
Aggiungendo una voce “kinesis” all’array “handlers” del logger di root, si sta indicando a quest\u2019ultimo di scrivere record di log sia in console che nel delivery stream di Kinesis Data Firehose.<\/p>\n
PS: il logger di root \u00e8 identificato da “” nella sezione “loggers”.<\/p>\n
Questo \u00e8 tutto ci\u00f2 che serve per la configurazione del producer dei dati di log di Kinesis Data Firehose. Concentriamoci ora sull’infrastruttura dietro l’API put_record_batch, quella utilizzata da KinesisFirehoseDeliveryStreamHandler per lo streaming dei record di log sul cloud.
\nDietro le quinte dell\u2019API put_record_batch<\/p>\n
I componenti dell’architettura necessari per aggregare i record di log dell’applicazione e renderli disponibili e ricercabili da una dashboard centralizzata sono i seguenti:<\/p>\n
un delivery stream di Kinesis Data Firehose;
\nun cluster del servizio Amazon Elasticsearch.<\/p>\n
Per creare un delivery stream di Kinesis Data Firehose, passiamo alla dashboard Kinesis della console di gestione AWS. Dal men\u00f9 a sinistra, selezioniamo Data Firehose. Una volta selezionato, dovremmo visualizzare un elenco di data stream presenti in una regione specifica del proprio account AWS. Per impostare un nuovo delivery stream, faremo clic sul pulsante Create delivery stream nell’angolo in alto a destra della pagina.
\n\"kinesis
\nNella procedura guidata di Create delivery stream ci verr\u00e0 chiesto di configurare l’origine del delivery stream, il processo di trasformazione, la destinazione e altre impostazioni come le autorizzazioni necessarie a Kinesis Data Firehose per caricare i dati di streaming nelle destinazioni specificate.<\/p>\n
Poich\u00e9 stiamo caricando i dati direttamente dal nostro logger tramite l\u2019SDK di boto3, dobbiamo scegliere Direct PUT or other sources come sorgente del delivery stream.
\n\"Firehose
\nLasciamo le opzioni \u201ctransform\u201d e \u201cconvert\u201d disabilitate in quanto non fondamentali ai risultati presentati in questo articolo.<\/p>\n
Il terzo step del wizard richiede di specificare le destinazioni del delivery stream. Assumendo che si sia gi\u00e0 creato un cluster di Amazon Elasticsearch nel proprio account AWS, questo verr\u00e0 specificato come destinazione primaria, indicando l\u2019index name di Elasticsearch, la rotation frequency, il mapping type e la retry duration, ovvero per quanto a lungo una richiesta fallita deve essere ritentata.
\n\"elasticsearch
\nCome destinazione secondaria del nostro delivery stream, imposteremo un bucket S3. Come gi\u00e0 accennato in precedenza, questo bucket conterr\u00e0 registri storici non soggetti alla logica di rotazione dell’indice di Elasticsearch.
\n\"s3
\nLasceremo disabilitate la compressione S3, la crittografia S3 e la registrazione degli errori e ci concentreremo sulle autorizzazioni. Quest’ultima sezione richiede di specificare o creare un nuovo ruolo IAM con una politica che consenta a Kinesis Data Firehose di trasmettere i dati alle destinazioni specificate. Facendo clic su Create new verremo guidati nella creazione di un ruolo IAM con il set di criteri di autorizzazione richiesto.<\/p>\n
Log record streaming test
\nUna volta che il delivery stream \u00e8 creato, possiamo testare finalmente se il codice e l\u2019architettura sono stati correttamente integrati. Il seguente schema illustra gli attori in gioco:
\n\"scheme\"
\nDalla propria macchina locale si andr\u00e0 a simulare una applicazione che andr\u00e0 a caricare i dati direttamente su un Kinesis Data Firehose delivery stream. Per questo test si andr\u00e0 ad utilizzare la configurazione a dizionario che gi\u00e0 include il KinesisFirehoseDeliveryStreamHandler.<\/p>\n
import logging.config\r\n\r\nconfig = {...}\r\n\r\nlogging.config.dictConfig(config)\r\nlogger = logging.getLogger(__name__)\r\n\r\n\r\ndef test():\r\n   try:\r\n       raise NameError(\"fake NameError\")\r\n   except NameError as e:\r\n       logger.error(e, exc_info=True)\r\n<\/pre>\n
Eseguendo il test, un nuovo record di log verr\u00e0 generato e scritto sia in console che sul delivery stream.
\nDi seguito l\u2019output della console in fase di test:<\/p>\n
{\"asctime\": \"2020-05-11T14:44:44+0200\", \"name\": \"logging_test5\", \"levelname\": \"ERROR\", \"message\": \"fake NameError\", \"exc_info\": \"Traceback (most recent call last):\\n  File \\\"\/Users\/ericvilla\/Projects\/logging-test\/src\/logging_test5.py\\\", line 42, in test\\n    raise NameError(\\\"fake NameError\\\")\\nNameError: fake NameError\"}<\/pre>\n
Beh, niente di nuovo. Ci\u00f2 che ci si aspetterebbe oltre all’output della console \u00e8 trovare anche il record di log nella nostra console di Kibana.<\/p>\n
Per consentire la ricerca e l’analisi dei record di log direttamente da Kibana, \u00e8 necessario creare un index pattern, utilizzato da Kibana per recuperare dati da specifici indici di Elasticsearch.<\/p>\n
Il nome che abbiamo dato all’indice Elasticsearch \u00e8 logging-test. Pertanto, gli indici verranno archiviati come logging-test-. Fondamentalmente, per far s\u00ec che Kibana recuperi i record di log da ciascun indice che inizi con logging-test-, si dovr\u00e0 definire il pattern di log logging-test- *. Se il nostro KinesisFirehoseDeliveryStreamHandler avr\u00e0 funzionato come previsto, l\u2019index pattern dovrebbe corrispondere ad un nuovo indice.
\n\"create
\nPer filtrare i record di log per orario, possiamo usare la chiave asctime che il formatter JSON avr\u00e0 aggiunto a tale record.
\n\"create
\nUna volta che L\u2019index pattern \u00e8 creato, possiamo finalmente ricercare ed analizzare i log direttamente dalla console di Kibana!<\/p>\n
\"kibana
\n\u00c8 possibile personalizzare ulteriormente l’esperienza di ricerca e analisi dei record di log, per eseguire il debug dell’applicazione in modo pi\u00f9 efficiente, aggiungendo filtri e creando dashboard.<\/p>\n
Detto tutto questo, qui si conclude il nostro viaggio alla scoperta del modulo di logging di Python, delle best practices e delle tecniche per aggregare log distribuiti. Speriamo vivamente che vi sia piaciuto leggere questo articolo e che abbiate potuto impare qualche nuovo trucco. Fino al prossimo articolo, state al sicuro \ud83d\ude42<\/p>\n
Leggi la Parte 1<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
In questa seconda parte del nostro viaggio alla scoperta dei segreti e delle best practice del logging in Python (se […]<\/p>\n","protected":false},"author":7,"featured_media":1445,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[477],"tags":[269,261,265,273],"class_list":["post-1443","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-cloud-native-development","tag-amazon-elasticsearch-service","tag-amazon-kinesis-data-firehose","tag-kibana","tag-python"],"yoast_head":"\nParte II: Best practice per il logging su Python e come integrarsi con la dashboard di Kibana tramite Amazon Kinesis Data Firehose e Amazon Elasticsearch Service - Proud2beCloud Blog<\/title>\n<meta name=\"description\" content=\"Gestire pi\u00f9 istanze applicative (e quindi pi\u00f9 stream di log), e aggregare i log usando Amazon Kinesis Data Firehose, Amazon ElasticSearch Service e Kibana.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/\" \/>\n<meta property=\"og:locale\" content=\"it_IT\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Parte II: Best practice per il logging su Python\" \/>\n<meta property=\"og:description\" content=\"Gestire pi\u00f9 istanze applicative (e quindi pi\u00f9 stream di log), e aggregare i log usando Amazon Kinesis Data Firehose, Amazon ElasticSearch Service e Kibana.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/\" \/>\n<meta property=\"og:site_name\" content=\"Proud2beCloud Blog\" \/>\n<meta property=\"article:published_time\" content=\"2020-05-29T10:50:29+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2021-03-17T14:18:09+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/blog.besharp.it\/wp-content\/uploads\/2020\/05\/copertine-blog-Recuperato-40.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1667\" \/>\n\t<meta property=\"og:image:height\" content=\"1251\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Eric Villa\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:title\" content=\"Parte II: Best practice per il logging su Python\" \/>\n<meta name=\"twitter:description\" content=\"Gestire pi\u00f9 istanze applicative (e quindi pi\u00f9 stream di log), e aggregare i log usando Amazon Kinesis Data Firehose, Amazon ElasticSearch Service e Kibana.\" \/>\n<meta name=\"twitter:image\" content=\"https:\/\/blog.besharp.it\/wp-content\/uploads\/2020\/05\/copertine-blog-Recuperato-40.png\" \/>\n<meta name=\"twitter:label1\" content=\"Scritto da\" \/>\n\t<meta name=\"twitter:data1\" content=\"Eric Villa\" \/>\n\t<meta name=\"twitter:label2\" content=\"Tempo di lettura stimato\" \/>\n\t<meta name=\"twitter:data2\" content=\"9 minuti\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/\",\"url\":\"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/\",\"name\":\"Parte II: Best practice per il logging su Python e come integrarsi con la dashboard di Kibana tramite Amazon Kinesis Data Firehose e Amazon Elasticsearch Service - Proud2beCloud Blog\",\"isPartOf\":{\"@id\":\"https:\/\/blog.besharp.it\/it\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/blog.besharp.it\/wp-content\/uploads\/2020\/05\/copertine-blog-Recuperato-40.png\",\"datePublished\":\"2020-05-29T10:50:29+00:00\",\"dateModified\":\"2021-03-17T14:18:09+00:00\",\"author\":{\"@id\":\"https:\/\/blog.besharp.it\/it\/#\/schema\/person\/2aae452eb3d76073c835d108b04c88e8\"},\"description\":\"Gestire pi\u00f9 istanze applicative (e quindi pi\u00f9 stream di log), e aggregare i log usando Amazon Kinesis Data Firehose, Amazon ElasticSearch Service e Kibana.\",\"breadcrumb\":{\"@id\":\"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/#breadcrumb\"},\"inLanguage\":\"it-IT\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@id\":\"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/#primaryimage\",\"url\":\"https:\/\/blog.besharp.it\/wp-content\/uploads\/2020\/05\/copertine-blog-Recuperato-40.png\",\"contentUrl\":\"https:\/\/blog.besharp.it\/wp-content\/uploads\/2020\/05\/copertine-blog-Recuperato-40.png\",\"width\":1667,\"height\":1251},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/blog.besharp.it\/it\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Parte II: Best practice per il logging su Python e come integrarsi con la dashboard di Kibana tramite Amazon Kinesis Data Firehose e Amazon Elasticsearch Service\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/blog.besharp.it\/it\/#website\",\"url\":\"https:\/\/blog.besharp.it\/it\/\",\"name\":\"Proud2beCloud Blog\",\"description\":\"il blog di beSharp\",\"alternateName\":\"Proud2beCloud Blog\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/blog.besharp.it\/it\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"it-IT\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/blog.besharp.it\/it\/#\/schema\/person\/2aae452eb3d76073c835d108b04c88e8\",\"name\":\"Eric Villa\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@id\":\"https:\/\/blog.besharp.it\/it\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/666de14295bdf007c4c04f336a9e887a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/666de14295bdf007c4c04f336a9e887a?s=96&d=mm&r=g\",\"caption\":\"Eric Villa\"},\"description\":\"Solutions Architect @beSharp | AWS Community Builder | AWS Authorized Instructor\",\"url\":\"https:\/\/blog.besharp.it\/it\/author\/eric-villa\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Parte II: Best practice per il logging su Python e come integrarsi con la dashboard di Kibana tramite Amazon Kinesis Data Firehose e Amazon Elasticsearch Service - Proud2beCloud Blog","description":"Gestire pi\u00f9 istanze applicative (e quindi pi\u00f9 stream di log), e aggregare i log usando Amazon Kinesis Data Firehose, Amazon ElasticSearch Service e Kibana.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/","og_locale":"it_IT","og_type":"article","og_title":"Parte II: Best practice per il logging su Python","og_description":"Gestire pi\u00f9 istanze applicative (e quindi pi\u00f9 stream di log), e aggregare i log usando Amazon Kinesis Data Firehose, Amazon ElasticSearch Service e Kibana.","og_url":"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/","og_site_name":"Proud2beCloud Blog","article_published_time":"2020-05-29T10:50:29+00:00","article_modified_time":"2021-03-17T14:18:09+00:00","og_image":[{"width":1667,"height":1251,"url":"https:\/\/blog.besharp.it\/wp-content\/uploads\/2020\/05\/copertine-blog-Recuperato-40.png","type":"image\/png"}],"author":"Eric Villa","twitter_card":"summary_large_image","twitter_title":"Parte II: Best practice per il logging su Python","twitter_description":"Gestire pi\u00f9 istanze applicative (e quindi pi\u00f9 stream di log), e aggregare i log usando Amazon Kinesis Data Firehose, Amazon ElasticSearch Service e Kibana.","twitter_image":"https:\/\/blog.besharp.it\/wp-content\/uploads\/2020\/05\/copertine-blog-Recuperato-40.png","twitter_misc":{"Scritto da":"Eric Villa","Tempo di lettura stimato":"9 minuti"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/","url":"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/","name":"Parte II: Best practice per il logging su Python e come integrarsi con la dashboard di Kibana tramite Amazon Kinesis Data Firehose e Amazon Elasticsearch Service - Proud2beCloud Blog","isPartOf":{"@id":"https:\/\/blog.besharp.it\/it\/#website"},"primaryImageOfPage":{"@id":"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/#primaryimage"},"image":{"@id":"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/#primaryimage"},"thumbnailUrl":"https:\/\/blog.besharp.it\/wp-content\/uploads\/2020\/05\/copertine-blog-Recuperato-40.png","datePublished":"2020-05-29T10:50:29+00:00","dateModified":"2021-03-17T14:18:09+00:00","author":{"@id":"https:\/\/blog.besharp.it\/it\/#\/schema\/person\/2aae452eb3d76073c835d108b04c88e8"},"description":"Gestire pi\u00f9 istanze applicative (e quindi pi\u00f9 stream di log), e aggregare i log usando Amazon Kinesis Data Firehose, Amazon ElasticSearch Service e Kibana.","breadcrumb":{"@id":"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/#breadcrumb"},"inLanguage":"it-IT","potentialAction":[{"@type":"ReadAction","target":["https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/"]}]},{"@type":"ImageObject","inLanguage":"it-IT","@id":"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/#primaryimage","url":"https:\/\/blog.besharp.it\/wp-content\/uploads\/2020\/05\/copertine-blog-Recuperato-40.png","contentUrl":"https:\/\/blog.besharp.it\/wp-content\/uploads\/2020\/05\/copertine-blog-Recuperato-40.png","width":1667,"height":1251},{"@type":"BreadcrumbList","@id":"https:\/\/blog.besharp.it\/it\/parte-ii-best-practice-per-il-logging-su-python-e-come-integrarsi-con-la-dashboard-di-kibana-tramite-amazon-kinesis-data-firehose-e-amazon-elasticsearch-service\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/blog.besharp.it\/it\/"},{"@type":"ListItem","position":2,"name":"Parte II: Best practice per il logging su Python e come integrarsi con la dashboard di Kibana tramite Amazon Kinesis Data Firehose e Amazon Elasticsearch Service"}]},{"@type":"WebSite","@id":"https:\/\/blog.besharp.it\/it\/#website","url":"https:\/\/blog.besharp.it\/it\/","name":"Proud2beCloud Blog","description":"il blog di beSharp","alternateName":"Proud2beCloud Blog","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/blog.besharp.it\/it\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"it-IT"},{"@type":"Person","@id":"https:\/\/blog.besharp.it\/it\/#\/schema\/person\/2aae452eb3d76073c835d108b04c88e8","name":"Eric Villa","image":{"@type":"ImageObject","inLanguage":"it-IT","@id":"https:\/\/blog.besharp.it\/it\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/666de14295bdf007c4c04f336a9e887a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/666de14295bdf007c4c04f336a9e887a?s=96&d=mm&r=g","caption":"Eric Villa"},"description":"Solutions Architect @beSharp | AWS Community Builder | AWS Authorized Instructor","url":"https:\/\/blog.besharp.it\/it\/author\/eric-villa\/"}]}},"_links":{"self":[{"href":"https:\/\/blog.besharp.it\/it\/wp-json\/wp\/v2\/posts\/1443","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.besharp.it\/it\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.besharp.it\/it\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.besharp.it\/it\/wp-json\/wp\/v2\/users\/7"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.besharp.it\/it\/wp-json\/wp\/v2\/comments?post=1443"}],"version-history":[{"count":0,"href":"https:\/\/blog.besharp.it\/it\/wp-json\/wp\/v2\/posts\/1443\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.besharp.it\/it\/wp-json\/wp\/v2\/media\/1445"}],"wp:attachment":[{"href":"https:\/\/blog.besharp.it\/it\/wp-json\/wp\/v2\/media?parent=1443"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.besharp.it\/it\/wp-json\/wp\/v2\/categories?post=1443"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.besharp.it\/it\/wp-json\/wp\/v2\/tags?post=1443"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}