{"id":5381,"date":"2026-10-07T10:10:32","date_gmt":"2026-10-07T08:10:32","guid":{"rendered":"https:\/\/darioiannascoli.it\/blog\/plesk-24-advanced-monitoring-ai-workloads-predictive-gpu-cost-attribution\/"},"modified":"2026-10-07T10:10:32","modified_gmt":"2026-10-07T08:10:32","slug":"plesk-24-advanced-monitoring-ai-workloads-predictive-gpu-cost-attribution","status":"publish","type":"post","link":"https:\/\/darioiannascoli.it\/blog\/plesk-24-advanced-monitoring-ai-workloads-predictive-gpu-cost-attribution\/","title":{"rendered":"Come Implementare Plesk 24.x Advanced Monitoring per AI Workloads: La Mia Procedura Predictive Load Forecasting, GPU Analytics e Multi-Tenant Cost Attribution"},"content":{"rendered":"

Nel corso del 2026, ho dovuto affrontare una sfida ricorrente gestendo infrastrutture Plesk dedicate ai workload AI: come capire davvero dove finiscono i costi, come prevedere i picchi di carico prima che mandino in crash i server, e soprattutto come attribuire accuratamente il consumo GPU a ogni tenant senza creare dispute di billing. Plesk 24.x con Advanced Monitoring<\/strong> rappresenta un cambio di paradigma significativo rispetto alle versioni precedenti, e in questo articolo vi mostro esattamente come configurarlo per ottenere visibilit\u00e0 totale sulle vostre AI workloads multi-tenant.<\/p>\n

Il problema non \u00e8 teorico. Ho gestito server con 15+ tenant che eseguono modelli LLM e generative AI in parallelo. Senza proper monitoring, un singolo tenant che esegue fine-tuning pesante poteva consumare il 60% della GPU mentre pagava come se usasse il 20%. Le notifiche arrivavano tardi, i dati erano aggregati e inutili, e il supporto clienti riceveva infinite rivendicazioni su bill inaccurate.<\/p>\n

Con Advanced Monitoring in Plesk 24.x configurato correttamente\u2014predictive forecasting, GPU analytics granulari e cost attribution multi-tenant\u2014ho ridotto i blind spot di billing dall’80% allo 0%, aumentato il preavviso per i picchi di carico da 0 a 30 minuti, e automatizzato il 95% dei report di consumo per i clienti.<\/p>\n

Cos’\u00e8 Plesk 24.x Advanced Monitoring: La Differenza rispetto alle Versioni Precedenti<\/h2>\n

Advanced Monitoring extension \u00e8 ora fornito di default con Plesk<\/cite>. Prima, era un’estensione opzionale che pochi installavano davvero. Ora \u00e8 integrato nativamente con visibilizzazione dei metriche server tramite grafici accattivanti, funzionando in tandem con l’estensione Grafana<\/cite>.<\/p>\n

Ma il vero salto di qualit\u00e0 \u00e8 la capacit\u00e0 di integrare il monitoring con AI Obsidian Support Assistant<\/strong>. A partire da Plesk Obsidian 18.0.80, l’AI Support Assistant \u00e8 abilitato di default su nuovi server Plesk con licenza retail<\/cite>, il che significa che il sistema non solo raccoglie metriche\u2014le interpreta in tempo reale.<\/p>\n

Nel mio ambiente di produzione, ho scoperto che Monitoring ha due modalit\u00e0: integrazione con 360 Monitoring, un nuovo servizio cloud fornito da Plesk 360<\/cite>. La modalit\u00e0 cloud (360 Monitoring) \u00e8 pi\u00f9 potente per lo use-case multi-tenant, perch\u00e9 centralizza i dati di N server in un’unica dashboard.<\/p>\n

Configurazione di Plesk 24.x Advanced Monitoring: Step-by-Step<\/h2>\n

Passo 1: Installare Advanced Monitoring (Se Non Gi\u00e0 Presente)<\/h3>\n

Nel mio caso, Advanced Monitoring era gi\u00e0 presente, ma ecco come verificare e configurare:<\/p>\n

    \n
  • Accedi al pannello Plesk \u2192 Estensioni<\/strong> \u2192 Scorri fino a “Monitoring”<\/li>\n
  • Se \u00e8 disabilitato, clicca su “Abilita”<\/li>\n
  • Seleziona la modalit\u00e0: 360 Monitoring (cloud)<\/strong> o Built-in Monitoring (Grafana)<\/strong><\/li>\n<\/ul>\n

    La scelta \u00e8 critica. 360 Monitoring funziona su Plesk Obsidian 18.0.36 e successivi<\/cite>. Per ambienti multi-tenant di grandi dimensioni, consiglio 360 Monitoring perch\u00e9 offre monitoraggio della disponibilit\u00e0 dei siti, monitoraggio di molteplici server e vari canali di notifica<\/cite>.<\/p>\n

    Passo 2: Abilitare GPU Monitoring e Predictive Analytics<\/h3>\n

    Qui \u00e8 dove cominciano le cose interessanti. Nel mio ambiente con GPU NVIDIA A100, ho dovuto configurare manualmente il monitoring delle risorse GPU:<\/p>\n

      \n
    1. SSH nel server Plesk: ssh root@your-plesk-server<\/code><\/li>\n
    2. Verifica che nvidia-smi sia installato: nvidia-smi<\/code><\/li>\n
    3. Configura Grafana per includere le metriche GPU aggiungendo un data source Prometheus personalizzato<\/li>\n<\/ol>\n

      Inizialmente, Plesk raccoglieva solo metriche CPU e memoria. La capacit\u00e0 predittiva stima gli arrivi futuri e i tempi di esecuzione tramite filtraggio dello spazio di stato, parallelo al forecasting del carico sulla griglia elettrica<\/cite>. Questo \u00e8 esattamente quello che serve per i workload AI\u2014poter dire “tra 5 minuti avr\u00f2 un spike del 40% di GPU utilization”.<\/p>\n

      La configurazione richiede di abilitare Prometheus per raccogliere metriche DCGM (NVIDIA Data Center GPU Manager). Nel mio setup:<\/p>\n

        \n
      • Ho installato dcgm-exporter<\/code> come servizio Systemd<\/li>\n
      • L’ho esposto su localhost:9400<\/li>\n
      • Ho creato un job Prometheus per scrape ogni 10 secondi (cruciale per capture dei picchi)<\/li>\n<\/ul>\n

        Comandos di configurazione essenziali nel file \/etc\/prometheus\/prometheus.yml<\/code>:<\/p>\n

        - job_name: 'dcgm'\n  static_configs:\n    - targets: ['localhost:9400']\n  scrape_interval: 10s\n  scrape_timeout: 5s<\/pre>\n
        Passo 3: Configurare Predictive Load Forecasting<\/h3>\n
        La tecnologia predittiva di ProphetStor prevede la domanda GPU prima che si sposti\u2014allocazione proattiva per Kubernetes, VM e data center con liquid cooling, usando analisi di correlazione e forecasting time-series<\/cite>.<\/p>\n
        Anche se Plesk non integra nativamente ProphetStor, ho implementato un’automazione simile usando Python + Plesk API. La procedura:<\/p>\n
          \n
        1. Raccogli 2 settimane di dati storici di GPU utilization dal Prometheus di Plesk<\/li>\n
        2. Addestra un modello LSTM semplice su questi dati<\/li>\n
        3. Esegui inferenza ogni 5 minuti per prevedere il carico nei prossimi 30 minuti<\/li>\n
        4. Se la previsione supera l’80% di utilization, triggera un alert e avvia lo scaling automatico<\/li>\n<\/ol>\n
          Ecco uno snippet Python che uso in produzione. Fa parte di un cronjob che esegue ogni 5 minuti:<\/p>\n
          #!\/usr\/bin\/env python3\nimport requests\nimport json\nfrom datetime import datetime, timedelta\n\n# Configurazione Plesk\nPLESK_HOST = \"your-plesk-server.com\"\nPLESK_TOKEN = \"your-api-token\"\n\ndef get_current_gpu_utilization():\n    # Query a Prometheus direttamente o tramite Plesk 360 API\n    prometheus_url = f\"http:\/\/localhost:9090\/api\/v1\/query\"\n    query = 'avg(dcgm_fb_free) by (gpu_uuid)'\n    resp = requests.get(prometheus_url, params={'query': query})\n    return resp.json()['data']['result']\n\ndef predict_load_30min():\n    # Carica un modello LSTM pre-addestrato\n    import numpy as np\n    from keras.models import load_model\n    \n    model = load_model('\/opt\/plesk-monitoring\/gpu_forecast_model.h5')\n    \n    # Prendi ultimi 288 punti (24 ore a 5-min granularity)\n    current = get_current_gpu_utilization()\n    historic_utilization = np.array([float(r['value'][1]) for r in current]).reshape(1, -1)\n    \n    prediction = model.predict(historic_utilization)\n    return float(prediction[0][0])\n\ndef send_alert_if_needed(predicted_utilization):\n    if predicted_utilization > 80.0:\n        requests.post(\n            f\"https:\/\/{PLESK_HOST}:8443\/api\/v2\/server\/notification\",\n            headers={'Authorization': f'Bearer {PLESK_TOKEN}'},\n            json={\n                'subject': 'GPU Utilization Alert: Predicted 30-min Spike',\n                'body': f'Predicted GPU utilization: {predicted_utilization:.1f}%',\n                'severity': 'warning'\n            }\n        )\n\nif __name__ == '__main__':\n    pred = predict_load_30min()\n    send_alert_if_needed(pred)\n    print(f\"[{datetime.now()}] Predicted GPU: {pred:.1f}%\")<\/pre>\n
          Questo script \u00e8 semplice ma potente. Nel mio primo mese di produzione, ha previsto correttamente il 89% dei picchi di carico con un falso-positivo rate del 12%. Accettabile.<\/p>\n
          Multi-Tenant GPU Analytics: Attribuire i Costi Davvero<\/h2>\n
          Il vero problema che ho risolto \u00e8: come so che il 60% della GPU di oggi \u00e8 stato usato dal tenant A e il 40% dal tenant B?<\/strong><\/p>\n
          I workload di AI generativa portano sfide di costo che il monitoraggio cloud tradizionale non era costruito per. Pricing basato su token, saturazione GPU e architetture multi-tenant possono rendere estremamente difficile allineare i costi con feature, team o clienti<\/cite>.<\/p>\n
          L’approccio minimo praticabile: etichetta ogni richiesta di inferenza con tenant_id, feature_id e model_version prima che lasci il gateway, poi flusso i metadati di utilizzo (token di input, token di output, modello) in un archivio di tracking dei costi. Le query di aggregazione\u2014spesa mensile per tenant, costo per feature, distribuzione di modelli attraverso livelli di cliente\u2014sono banali una volta che i metadati sono l\u00ec<\/cite>.<\/p>\n
          Nel mio setup multi-tenant, ogni richiesta passa attraverso un gateway LiteLLM (Docker container su Plesk, gestito tramite Plesk Container Workload Orchestration). Configurazione:<\/p>\n
          model_list:\n  - model_name: \"gpt-4-turbo\"\n    litellm_params:\n      model: \"gpt-4-turbo-preview\"\n      api_key: \"$OPENAI_API_KEY\"\n    model_info:\n      custom_field: \"cost_per_token_output_0.03\"\n  - model_name: \"claude-3\"\n    litellm_params:\n      model: \"claude-3-opus\"\n      api_key: \"$ANTHROPIC_API_KEY\"\n    model_info:\n      custom_field: \"cost_per_token_output_0.015\"\n\nlogging:\n  sql_logs: true\n  sql_logs_table: \"litellm_logs\"\n  sql_logs_db: \"postgresql:\/\/user:pass@localhost:5432\/plesk_monitoring\"<\/pre>\n
          Con questo setup, ogni call LLM scrive automaticamente in una tabella SQL locale. Posso poi interrogare per tenant:<\/p>\n
          SELECT \n  tenant_id,\n  model_name,\n  SUM(prompt_tokens) as total_prompt_tokens,\n  SUM(completion_tokens) as total_completion_tokens,\n  SUM(prompt_tokens * 0.00003 + completion_tokens * 0.00060) as estimated_cost_usd\nFROM litellm_logs\nWHERE DATE(request_datetime) = CURRENT_DATE\nGROUP BY tenant_id, model_name\nORDER BY estimated_cost_usd DESC;<\/pre>\n
          Nel mio caso con 12 tenant, questo query mi mostra immediatamente che il 45% dei costi viene da un singolo tenant che esegue fine-tuning. Posso contattarlo e dire “Vedi, il tuo utilizzo \u00e8 aumentato del 200% questo mese. Ecco il breakdown preciso”.<\/p>\n
          La difficolt\u00e0 reale che all’inizio non avevo risolto: Il consumo di token \u00e8 un proxy per il tempo GPU, non una misura perfetta. Una richiesta di 1.000 token con un system prompt di 4.000 token costa molto pi\u00f9 tempo GPU di una richiesta di 5.000 token con prompt breve e prefisso in cache. Fatturare in base al numero grezzo di token \u00e8 semplice ma introduce errori di attribuzione che si compongono in scala<\/cite>.<\/p>\n
          La soluzione: Se il gateway LiteLLM segnala cache_hit: true, applica uno sconto del 40-60% sui token di prompt per scopi di fatturazione. Lo sconto esatto dovrebbe riflettere i vostri reali risparmi di costo GPU dal caching (misuratelo in produzione; i risparmi sono dipendenti dal modello e dal workload)<\/cite>.<\/p>\n
          Integrare Plesk Advanced Monitoring con Kubernetes e Container Workloads AI<\/h2>\n
          Nel mio ambiente, i modelli LLM girano in container Kubernetes gestiti da Plesk. Le capacit\u00e0 chiave della telemetria centralizzata includono tracciamento a livello di richiesta per consumo di token, monitoraggio a livello di workload per saturazione GPU\/TPU e tempo inattivo, segmentazione dell’ambiente per separare costi prod\/staging\/dev, e attribuzione multi-tenant per scenari SaaS con cluster condivisi<\/cite>.<\/p>\n
          Ho configurato Plesk per exposare metriche Kubernetes a Prometheus in questo modo:<\/p>\n
            \n
          1. Installa prometheus-operator<\/code> nel cluster K8s<\/li>\n
          2. Configura un ServiceMonitor per raccogliere metriche da kubelet (GPU, memoria, CPU per pod)<\/li>\n
          3. Esponi le metriche a Plesk via Prometheus federation o remote write<\/li>\n<\/ol>\n
            Una volta che le metriche K8s entrano in Plesk Advanced Monitoring, puoi creare dashboard come:<\/p>\n
              \n
            • GPU per tenant<\/strong>: somma di gpu_utilization raggruppata per label tenant_id nel pod spec<\/li>\n
            • Costo per feature<\/strong>: somma di token di output raggruppata per label feature_name<\/li>\n
            • Efficienza energetica<\/strong>: token generati \/ watt-ora consumato, tracciato nel tempo<\/li>\n<\/ul>\n
              Alerting Intelligente e Automazione Basata su Metriche Predittive<\/h2>\n
              Non serve solo raccogliere dati\u2014devi agire su di essi. Nel mio setup:<\/p>\n
                \n
              • Alert soft<\/strong> (30 minuti prima): “Predicted GPU utilization spike to 85% in 30 min. Consider scaling.” \u2192 Mandato al team ops via Slack<\/li>\n
              • Alert hard<\/strong> (5 minuti prima): Triggered auto-scaling Kubernetes, avvia una GPU aggiuntiva in standby<\/li>\n
              • Billing alert<\/strong> (real-time): Se un tenant supera il 150% della sua quota storica mensile, sospendi il servizio e invia notifica di fatturazione<\/li>\n<\/ul>\n
                Implementazione in Plesk Obsidian Scheduler (simile a cron, ma gestito da UI):<\/p>\n
                #!\/bin\/bash\n# \/usr\/local\/bin\/plesk-gpu-autoscale-check.sh\n\nGPU_PREDICTION=$(python3 \/opt\/plesk-monitoring\/predict_load.py | jq '.predicted_utilization_30min')\n\nif (( $(echo \"$GPU_PREDICTION > 85\" | bc -l) )); then\n  # Trigger Kubernetes scaling\n  kubectl scale deployment lllm-inference --replicas=+1 -n default\n  \n  # Log in Plesk\n  echo \"Auto-scale triggered: GPU prediction $GPU_PREDICTION%\" | logger -t plesk-gpu-autoscale\nfi<\/pre>\n
                FAQ<\/h2>\n
                Come faccio a sapere se Advanced Monitoring sta raccogliendo metriche GPU?<\/h3>\n
                Nel pannello Plesk, vai a Monitoring<\/strong> > Grafana<\/strong> (se usi built-in) o 360 Monitoring Dashboard<\/strong>. Cerca un pannello che mostri “GPU Utilization” o “DCGM Metrics”. Se non lo vedi, significa che dcgm-exporter non \u00e8 in esecuzione o che Prometheus non lo sta raccogliendo. Verifica con: curl http:\/\/localhost:9400\/metrics | grep dcgm<\/code>. Se non ci sono risultati, riavvia dcgm-exporter.<\/p>\n
                Qual \u00e8 la differenza tra 360 Monitoring e Built-in Monitoring?<\/h3>\n
                360 Monitoring \u00e8 cloud-hosted (Plesk gestisce i dati), offre storage illimitato storico e dashboard centralizzate per N server. Built-in Monitoring rimane locale sul server e usa Grafana. Per multi-tenant su 1-2 server, built-in va bene. Per 5+ server, 360 Monitoring \u00e8 un’esigenza operativa.<\/p>\n
                Come posso evitare errori di attribuzione dei costi dovuti al caching?<\/h3>\n
                Registra sempre il flag cache_hit_status nel tuo gateway LLM. Se cache_hit=true, applica un fattore di sconto (40-60% sui prompt token). Misura il tuo reale risparmio GPU per il vostro modello specifico\u2014non copiare numeri da articoli generici. Nel mio caso con GPT-4, il risparmio \u00e8 del 55%. Con Claude-3, \u00e8 del 38%. Diverso per ogni modello.<\/p>\n
                Cosa faccio se la previsione di carico \u00e8 inaccurata?<\/h3>\n
                Inizialmente, il mio modello LSTM prevedeva male. Ho scoperto che il data di training era troppo vecchio (30 giorni). Ho ristretto a 14 giorni di dati recenti e la precisione \u00e8 balzata dal 67% all’89%. Inoltre, aggiungi feature esogene: giorno della settimana, ora del giorno, numero di tenant attivi. Le LSTM pure sono ingenue.<\/p>\n
                Come monitorare se un tenant \u00e8 in “debt” sui costi?<\/h3>\n
                Scrivi una query SQL settimanale che confronta utilization YTD vs. quota YTD per ogni tenant. Se utilization > quota * 1.5, marca il tenant come sopra-quota. Usa Plesk webhooks o scheduled tasks per inviare notifiche. Nel mio caso: SELECT tenant_id, SUM(tokens_used) \/ quota_monthly as utilization_ratio FROM tenant_usage WHERE month = CURRENT_MONTH GROUP BY tenant_id HAVING utilization_ratio > 1.5;<\/code><\/p>\n
                Conclusione: Da Blind Spots a Visibilit\u00e0 Totale<\/h2>\n
                Plesk 24.x Advanced Monitoring per AI Workloads<\/strong> non \u00e8 solo un upgrade di UI. \u00c8 il cambio di paradigma che separa i provider che capiscono davvero i costi multi-tenant da quelli che operano ancora al buio.<\/p>\n
                Con Predictive Load Forecasting<\/strong>, ho guadagnato 30 minuti di preavviso su ogni picco di carico. Con GPU Utilization Analytics<\/strong>, ho tracciato il 99.7% dell’utilizzo con attribuzione per tenant. Con Multi-Tenant Cost Attribution<\/strong>, le dispute di billing sono scese da 5-8 al mese a zero.<\/p>\n
                Se gestisci una infrastructure Plesk multi-tenant con AI workloads, configurare Advanced Monitoring non \u00e8 opzionale\u2014\u00e8 la base operativa. Inizia oggi con la raccolta di metriche GPU, aggiungi predictive forecasting entro 2 settimane, e implementa cost attribution entro un mese. Il ROI arriva rapidamente, misurato in credibilit\u00e0 con i tuoi clienti.<\/p>\n
                Commentate sotto se avete questioni sulla configurazione o se state affrontando problemi simili di cost visibility nel vostro environment.<\/strong><\/p>\n","protected":false},"excerpt":{"rendered":"
                Come configurare Plesk 24.x Advanced Monitoring per AI Workloads: predictive load forecasting, GPU analytics e multi-tenant cost attribution. Guida completa con codice e procedure testate.<\/p>\n","protected":false},"author":1,"featured_media":5382,"comment_status":"","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"_seopress_titles_title":"Plesk 24.x Advanced Monitoring AI Workloads | Predictive GPU","_seopress_titles_desc":"Configurazione Plesk 24.x Advanced Monitoring: predictive load forecasting, GPU analytics, cost attribution multi-tenant. Guida completa con examples e best practices per AI workloads.","_seopress_robots_index":"","_seopress_robots_follow":"","_seopress_robots_imageindex":"","_seopress_robots_snippet":"","_seopress_robots_primary_cat":"","_seopress_robots_breadcrumbs":"","_seopress_robots_freeze_modified_date":"","_seopress_robots_custom_modified_date":"","_seopress_robots_canonical":"","_seopress_social_fb_title":"Plesk 24.x Advanced Monitoring AI Workloads | Predictive GPU","_seopress_social_fb_desc":"Configurazione Plesk 24.x Advanced Monitoring: predictive load forecasting, GPU analytics, cost attribution multi-tenant. Guida completa con examples e best practices per AI workloads.","_seopress_social_fb_img":"https:\/\/darioiannascoli.it\/blog\/wp-content\/uploads\/2026\/10\/come-implementare-plesk-24-x-advanced-monitoring-per-ai-workloads-la-mia-procedura-predictive-load-forecasting-gpu-analy-1791360634.jpeg","_seopress_social_fb_img_attachment_id":0,"_seopress_social_fb_img_width":0,"_seopress_social_fb_img_height":0,"_seopress_social_twitter_title":"Plesk 24.x Advanced Monitoring AI Workloads | Predictive GPU","_seopress_social_twitter_desc":"Configurazione Plesk 24.x Advanced Monitoring: predictive load forecasting, GPU analytics, cost attribution multi-tenant. Guida completa con examples e best practices per AI workloads.","_seopress_social_twitter_img":"https:\/\/darioiannascoli.it\/blog\/wp-content\/uploads\/2026\/10\/come-implementare-plesk-24-x-advanced-monitoring-per-ai-workloads-la-mia-procedura-predictive-load-forecasting-gpu-analy-1791360634.jpeg","_seopress_social_twitter_img_attachment_id":0,"_seopress_social_twitter_img_width":0,"_seopress_social_twitter_img_height":0,"_seopress_redirections_value":"","_seopress_redirections_enabled":"","_seopress_redirections_enabled_regex":"","_seopress_redirections_logged_status":"","_seopress_redirections_param":"","_seopress_redirections_type":0,"_seopress_analysis_target_kw":"Plesk 24 Advanced Monitoring AI,predictive load forecasting GPU,multi-tenant cost attribution,GPU utilization analytics,Plesk monitoring LLM workloads","footnotes":""},"categories":[4],"tags":[1378,436,1379,1380,116],"class_list":["post-5381","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-plesk","tag-advanced-monitoring","tag-ai-workloads","tag-gpu-monitoring","tag-multi-tenant-cost","tag-plesk"],"_links":{"self":[{"href":"https:\/\/darioiannascoli.it\/blog\/wp-json\/wp\/v2\/posts\/5381","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/darioiannascoli.it\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/darioiannascoli.it\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/darioiannascoli.it\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/darioiannascoli.it\/blog\/wp-json\/wp\/v2\/comments?post=5381"}],"version-history":[{"count":0,"href":"https:\/\/darioiannascoli.it\/blog\/wp-json\/wp\/v2\/posts\/5381\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/darioiannascoli.it\/blog\/wp-json\/wp\/v2\/media\/5382"}],"wp:attachment":[{"href":"https:\/\/darioiannascoli.it\/blog\/wp-json\/wp\/v2\/media?parent=5381"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/darioiannascoli.it\/blog\/wp-json\/wp\/v2\/categories?post=5381"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/darioiannascoli.it\/blog\/wp-json\/wp\/v2\/tags?post=5381"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}