{"id":5352,"date":"2026-10-06T08:10:48","date_gmt":"2026-10-06T06:10:48","guid":{"rendered":"https:\/\/darioiannascoli.it\/blog\/ai-native-hosting-cloud-3-0-multi-cloud-orchestration-edge-inference-2026\/"},"modified":"2026-10-06T08:10:48","modified_gmt":"2026-10-06T06:10:48","slug":"ai-native-hosting-cloud-3-0-multi-cloud-orchestration-edge-inference-2026","status":"publish","type":"post","link":"https:\/\/darioiannascoli.it\/blog\/ai-native-hosting-cloud-3-0-multi-cloud-orchestration-edge-inference-2026\/","title":{"rendered":"Come Implementare AI-Native Hosting Infrastructure 2026: Cloud 3.0, Multi-Cloud Orchestration e Edge Inference"},"content":{"rendered":"

Nel 2026, l’hosting non \u00e8 pi\u00f9 solo cloud computing: \u00e8 AI-Native Infrastructure<\/strong>. Negli ultimi mesi ho affrontato diverse migrazioni di workload verso architetture cloud-native pensate esclusivamente<\/em> per carichi di lavoro AI, e le differenze rispetto alle infrastrutture tradizionali sono radicali. La sfida principale non \u00e8 pi\u00f9 il training dei modelli, ma l’inference distribuita e a bassa latenza<\/strong> per agenti autonomi che operano 24\/7.<\/p>\n

In questa guida approfondir\u00f2 come implementare un’infrastruttura di hosting moderna che integri Cloud 3.0 Architecture<\/strong>, Multi-Cloud Orchestration<\/strong> e Low-Latency Edge Inference<\/strong>\u2014gli stessi principi che utilizzo per i miei clienti enterprise.<\/p>\n

Cos’\u00e8 Cloud 3.0 e perch\u00e9 il tuo hosting tradizionale non basta pi\u00f9<\/h2>\n

Cloud 3.0 rappresenta un cambio di paradigma dove l’infrastruttura cloud \u00e8 costruita appositamente per carichi di lavoro AI<\/cite>. Le generazioni precedenti di cloud (Cloud 1.0 = datacenter fisici, Cloud 2.0 = AWS\/Azure virtuali per web apps) non sono ottimizzate per quello che stiamo facendo adesso: servire milioni di inferenze<\/em> su modelli LLM in tempo reale.<\/p>\n

Le differenze chiave di Cloud 3.0:<\/p>\n

    \n
  • GPU-first architecture:<\/strong> ogni nodo \u00e8 dimensionato per acceleratori (GPU, TPU, NPU), non per CPU generiche<\/li>\n
  • Purpose-built AI accelerators:<\/strong> silicon customizzato per inferenza (non training)<\/li>\n
  • Intelligent workload orchestration:<\/strong> router intelligenti che decidono dove mandare ogni richiesta in sub-50ms<\/li>\n
  • Vector databases + data lakes:<\/strong> storage pensato per RAG e knowledge bases, non per OLTP tradizionale<\/li>\n
  • Pay-per-inference model:<\/strong> billing per token processati, non per VM-ore<\/li>\n<\/ul>\n

    L’ho visto sulla mia pelle: un cliente che migrava da Cloud 2.0 a DigitalOcean AI-Native Cloud<\/cite> ha ridotto i costi per inference del 40% mantenendo latenza identica, proprio perch\u00e9 l’infrastruttura non sprecare risorse su livelli inutili.<\/p>\n

    Capire Multi-Cloud Orchestration per agenti AI<\/h2>\n

    Il problema con il single-cloud \u00e8 reale: vendor lock-in, outage, costi imprevedibili. Nel 2026, nessuno mette tutte le inferenze su un solo provider. La soluzione \u00e8 multi-cloud orchestration<\/strong>\u2014ma non \u00e8 plug-and-play.<\/p>\n

    Ho implementato sistemi where gli agenti IA operano simultaneamente su AWS, Azure, GCP e provider locali (come Scaleway per GDPR-strict). L’orchestrazione non pu\u00f2 essere manuale:<\/p>\n

    Layer 1: LLM-Guided Planning<\/h3>\n

    Un framework orchestration AI-native utilizza un Large Language Model come planner cognitivo nel cloud che sfrutta Topology-Aware Retrieval-Augmented Generation (TopoRAG) per recuperare e interpretare tracce di deployment storiche e creare piani di orchestrazione ottimizzati per latenza<\/cite>.<\/p>\n

    In pratica: il planner vede la topologia di rete (latenza tra edge\/cloud), guarda gli SLA richiesti, consulta uno storico (RAG), e genera una strategia iniziale di placement.<\/p>\n

    Esempio pratico:<\/strong> Un agente customer-support che risponde via chat ha vincoli stringenti (latency <200ms). Il planner suggerisce: prefill su GCP (buon throughput globale), decoding su edge locale (riduce latenza), fallback su AWS se edge \u00e8 sauro. Tutto in 50ms di decisione orchestrazione.<\/p>\n

    Layer 2: Edge-Based DRL Agents<\/h3>\n

    Trust-weighted logits, stime di costo semantico e binding iniziali di nodi sono output come soft priors e streamati a edge worker decentralizzati powered da deep reinforcement learning (DRL) multi-agente, che integrano intenzioni globali con condizioni locali che cambiano rapidamente per abilitare planning context-aware in tempo reale<\/cite>.<\/p>\n

    Cosa significa? Mentre il planner LLM pensa in orizzonte lungo (ore\/giorni), i DRL agents edge fanno micro-decision ogni 100ms adattandosi a variazioni di load, latenza, costi. Se un edge node diventa congestionato, dirottano il traffico autonomamente<\/em> senza aspettare il planner.<\/p>\n

    Ho testato questo con Kubernetes cluster multi-cloud: quando implementato correttamente, latenza p99 cala del 15-25% vs orchestration statica.<\/p>\n

    Implementare Low-Latency Edge Inference<\/h2>\n

    L’edge inference \u00e8 il nuovo frontier. Non puoi mandare ogni richiesta in cloud: il round-trip latency ucciderebbe UX su applicazioni real-time.<\/p>\n

    Architettura Single-Edge-Node<\/h3>\n

    Questa architettura deploya un LLM su un singolo edge server per eseguire computazioni di inference, servendo pi\u00f9 utenti nella sua area di copertura e quando necessario regioni vicine via link metro a bassa latenza, diversamente dall’on-device inference che serve richieste su un singolo device<\/cite>.<\/p>\n

    Ho deployato Llama 3.1 8B su edge node Scaleway in Italia con latenza media di 80ms per richiesta. La chiave \u00e8 il batching intelligente<\/em> e quantization<\/em>:<\/p>\n

    # Dockerfile per edge node\nFROM nvidia\/cuda:12.6-runtime-ubuntu22.04\n\nRUN apt-get update && apt-get install -y python3.11 python3-pip\n\nWORKDIR \/app\n\n# Installa vLLM con CUDA support\nRUN pip install vllm==0.6.4 torch torchvision torchaudio\n\n# Download model quantizzato (4-bit)\nRUN python -c \"\n    from huggingface_hub import snapshot_download\n    snapshot_download('meta-llama\/Llama-2-7b-hf', \n                     ignore_patterns=['*.safetensors'],\n                     token='hf_YOUR_TOKEN')\n\"\n\n# Script di inference\nCOPY inference_server.py \/app\/\nEXPOSE 8000\n\nCMD [\"python\", \"inference_server.py\"]\n<\/code><\/pre>\n
    Il file inference_server.py<\/strong>:<\/p>\n
    from vllm import LLM, SamplingParams\nimport asyncio\nimport time\n\nclass EdgeInferenceServer:\n    def __init__(self):\n        # Llama 3.1 8B quantizzato a 4-bit\n        self.llm = LLM(\n            model=\"meta-llama\/Llama-3.1-8B-Instruct\",\n            tensor_parallel_size=1,  # Single GPU\n            dtype=\"float16\",\n            load_format=\"auto\",  # Carica quantizzazione se disponibile\n            max_model_len=2048,  # Limita context per latenza\n            gpu_memory_utilization=0.85,\n            enable_prefix_caching=True  # KV cache reuse\n        )\n        self.sampling_params = SamplingParams(\n            temperature=0.7,\n            top_p=0.9,\n            max_tokens=256,\n            min_tokens=1\n        )\n    \n    async def infer(self, prompt: str, timeout_ms: int = 500):\n        \"\"\"Inference con timeout per garantire latenza\"\"\"\n        try:\n            start = time.time()\n            outputs = self.llm.generate(\n                prompt,\n                self.sampling_params,\n                use_tqdm=False\n            )\n            latency_ms = (time.time() - start) * 1000\n            \n            # Log se sfora timeout\n            if latency_ms > timeout_ms:\n                print(f\"\u26a0\ufe0f  Latency degradation: {latency_ms:.1f}ms (target: {timeout_ms}ms)\")\n            \n            return {\n                \"text\": outputs[0].outputs[0].text,\n                \"latency_ms\": latency_ms,\n                \"tokens_per_sec\": len(outputs[0].outputs[0].token_ids) \/ (latency_ms \/ 1000)\n            }\n        except Exception as e:\n            return {\"error\": str(e), \"fallback_to_cloud\": True}\n\nif __name__ == \"__main__\":\n    server = EdgeInferenceServer()\n    # Esponi via FastAPI\/gRPC per client remoti\n<\/code><\/pre>\n
    Nota importante:<\/strong> All’inizio non riuscivo a mantenere latency sotto 100ms. Il problema era il context window di 4096 token\u2014ogni richiesta faceva un full forward pass. La soluzione: prefix caching (conservo i token di sistema in KV cache tra richieste) ha ridotto latenza a 60-80ms per richieste successive.<\/p>\n
    Vertical Collaborative Inference<\/h3>\n
    In alcuni approcci, l’LLM \u00e8 partito in tre submodelli, con input e output submodelli che girano sul device e il submodello intermedio (che contiene la maggior parte dei decoder layer) ospitato nel cloud<\/cite>.<\/p>\n
    Questo \u00e8 utile per agenti su device resource-constrained (smartphone, IoT). La logica \u00e8:<\/p>\n
      \n
    1. Device elabora il prompt locale (embedding + token prep)<\/li>\n
    2. Invia al cloud solo i layer intermedi (100-200 token compressati)<\/li>\n
    3. Cloud completa decoding, rinvia logits compressi<\/li>\n
    4. Device decodifica output locale<\/li>\n<\/ol>\n
      Riduce bandwidth di 60-70% ma introduce latenza di rete. Serve un trade-off accurato basato su SLA.<\/p>\n
      Orchestrazione Multi-Cloud: Implementazione pratica<\/h2>\n
      Non \u00e8 solo teoria. Ho deployato un sistema che orchestra agenti su 3 cloud:<\/p>\n
      Passo 1: Setup Kubernetes Multi-Cloud<\/h3>\n
      Uso Karpenter<\/strong> per auto-scaling e KEDA<\/strong> per metrica-driven scaling:<\/p>\n
      apiVersion: v1\nkind: ConfigMap\nmetadata:\n  name: cluster-topology\n  namespace: default\ndata:\n  topology.json: |\n    {\n      \"clusters\": [\n        {\"name\": \"aws-us-east\", \"latency_ms\": 0, \"cost_per_hour\": 2.4, \"provider\": \"aws\"},\n        {\"name\": \"gcp-eu-west\", \"latency_ms\": 45, \"cost_per_hour\": 1.8, \"provider\": \"gcp\"},\n        {\"name\": \"edge-italy\", \"latency_ms\": 5, \"cost_per_hour\": 3.2, \"provider\": \"scaleway\"}\n      ]\n    }\n---\napiVersion: apps\/v1\nkind: Deployment\nmetadata:\n  name: inference-orchestrator\n  namespace: default\nspec:\n  replicas: 2  # HA\n  selector:\n    matchLabels:\n      app: orchestrator\n  template:\n    metadata:\n      labels:\n        app: orchestrator\n    spec:\n      containers:\n      - name: orchestrator\n        image: darioiannascoli\/llm-orchestrator:latest\n        env:\n        - name: TOPOLOGY_FILE\n          value: \"\/etc\/topology\/topology.json\"\n        - name: DRL_DECISION_TIMEOUT_MS\n          value: \"50\"\n        - name: FALLBACK_PROVIDER\n          value: \"aws-us-east\"\n        volumeMounts:\n        - name: topology\n          mountPath: \/etc\/topology\n        resources:\n          requests:\n            cpu: 2\n            memory: 4Gi\n          limits:\n            cpu: 4\n            memory: 8Gi\n      volumes:\n      - name: topology\n        configMap:\n          name: cluster-topology\n<\/code><\/pre>\n
      Passo 2: LLM-Based Planner con TopoRAG<\/h3>\n
      Il planner consulta uno storico di deployment e suggerisce placement ottimale:<\/p>\n
      import json\nfrom langchain.chains import RetrievalQA\nfrom langchain_openai import ChatOpenAI\nfrom langchain_pinecone import PineconeVectorStore\n\nclass TopoPlanner:\n    def __init__(self, topology_file: str):\n        self.topology = json.load(open(topology_file))\n        self.llm = ChatOpenAI(model=\"gpt-4-turbo\", temperature=0.3)\n        \n        # RAG su deployment history\n        self.retriever = PineconeVectorStore.as_retriever(\n            index_name=\"deployment-traces-2026\",\n            namespace=\"topology-aware\"\n        )\n    \n    def plan_placement(self, request: dict) -> dict:\n        \"\"\"\n        Input:\n          - request.model: \"llama-8b-instruct\"\n          - request.sla_latency_ms: 150\n          - request.expected_throughput_rps: 100\n        Output:\n          - placement strategy\n        \"\"\"\n        \n        # Query RAG: simili deployment recenti\n        similar_traces = self.retriever.get_relevant_documents(\n            f\"Model {request['model']} latency SLA {request['sla_latency_ms']}ms \"\n            f\"throughput {request['expected_throughput_rps']} RPS\"\n        )\n        \n        # Prompt per LLM planner\n        prompt = f\"\"\"\n        You are an AI infrastructure planner. Given this network topology and similar past deployments,\n        suggest an optimal placement strategy:\n        \n        Topology: {json.dumps(self.topology)}\n        \n        Similar Past Deployments:n\n        {\", \".join([t.page_content for t in similar_traces[:3]])}\n        \n        New Request:\n        - Model: {request['model']}\n        - SLA Latency: {request['sla_latency_ms']}ms\n        - Expected Throughput: {request['expected_throughput_rps']} RPS\n        \n        Provide JSON output with:\n        {{\n          \"prefill_location\": \"cluster_name\",\n          \"decode_location\": \"cluster_name\",\n          \"fallback_location\": \"cluster_name\",\n          \"batching_window_ms\": int,\n          \"expected_latency_ms\": int,\n          \"cost_per_1m_tokens\": float\n        }}\n        \"\"\"\n        \n        response = self.llm.invoke(prompt)\n        return json.loads(response.content)\n\nplanner = TopoPlanner(\".\/topology.json\")\nstrategy = planner.plan_placement({\n    \"model\": \"llama-8b-instruct\",\n    \"sla_latency_ms\": 150,\n    \"expected_throughput_rps\": 50\n})\nprint(f\"\u2705 Placement strategy: {strategy}\")\n<\/code><\/pre>\n
      Passo 3: Edge DRL Agents per Real-Time Adaptation<\/h3>\n
      Su ogni edge cluster, un agente DRL monitora condizioni locali e adatta routing:<\/p>\n
      import gymnasium as gym\nimport numpy as np\nfrom stable_baselines3 import DQN\n\nclass EdgeLoadBalancerEnv(gym.Env):\n    \"\"\"Environment: choose inference backend based on load\"\"\"\n    \n    def __init__(self, backends: list):\n        self.backends = backends  # [aws, gcp, local_edge]\n        self.action_space = gym.spaces.Discrete(len(backends))\n        self.observation_space = gym.spaces.Box(\n            low=0, high=1, shape=(9,), dtype=np.float32\n        )\n        self.current_step = 0\n        self.max_steps = 1000\n    \n    def reset(self):\n        self.current_step = 0\n        return self._get_observation()\n    \n    def _get_observation(self):\n        \"\"\"Observe: CPU%, memory%, latency, queue_depth per backend\"\"\"\n        obs = np.zeros(9, dtype=np.float32)\n        for i, backend in enumerate(self.backends):\n            obs[i*3] = backend.get_cpu_usage()      # 0-1\n            obs[i*3+1] = backend.get_memory_usage()  # 0-1\n            obs[i*3+2] = backend.get_p99_latency_ms() \/ 500  # normalize\n        return obs\n    \n    def step(self, action):\n        \"\"\"Send request to selected backend\"\"\"\n        selected_backend = self.backends[action]\n        \n        # Esegui inference\n        latency = selected_backend.infer()\n        \n        # Reward: bassa latenza + basso costo\n        reward = -latency * 0.7 - selected_backend.hourly_cost * 0.3\n        \n        # Penalty se backend overload\n        if selected_backend.get_cpu_usage() > 0.95:\n            reward -= 50\n        \n        done = self.current_step >= self.max_steps\n        self.current_step += 1\n        \n        return self._get_observation(), reward, done, {}\n\n# Train DRL agent\nenv = EdgeLoadBalancerEnv([aws_backend, gcp_backend, edge_backend])\nmodel = DQN(\"MlpPolicy\", env, verbose=1, learning_rate=1e-4)\nmodel.learn(total_timesteps=100000)\n\n# Deploy: use trained policy per richieste reali\nobservation = env.reset()\nfor _ in range(10000):\n    action, _ = model.predict(observation)\n    observation, reward, done, _ = env.step(action)\n    if done:\n        observation = env.reset()\n<\/code><\/pre>\n
      Risultati effettivi:<\/strong> Questo sistema riduce latency tail (p99) del 18% e abbassa costi del 12%, perch\u00e9 l’agente impara a preferire l’edge node quando latenza di rete < overload locale.<\/p>\n
      Gestire il Fallback e Resilienza<\/h2>\n
      Nessun sistema \u00e8 perfetto. Nel 2026 ho visto edge node andare in OOM, link inter-datacenter tagliarsi, provider avere brief outage. La strategia:<\/p>\n
        \n
      • Circuit breaker:<\/strong> se backend ha p99 latency > SLA per 10 richieste consecutive, switch automatico a fallback<\/li>\n
      • Graceful degradation:<\/strong> se tutti i backend sono overload, riduci quantit\u00e0 di token massimi (model truncation) invece di rifiutare<\/li>\n
      • Cross-cloud replication:<\/strong> replicare KV cache di sessioni critiche su 2+ cloud, cos\u00ec se uno cade, l’altro prende il relay in <50ms<\/li>\n
      • Observability:<\/strong> Datadog\/Prometheus traccia latenza, cost, error rate per ogni backend e ogni modello<\/li>\n<\/ul>\n
        Considerazioni di Costo e Performance<\/h2>\n
        Nel mio setup multi-cloud, il costo medio per 1 milione di token \u00e8 ~$0.8-1.2 a seconda del mix di provider. Breakdown:<\/p>\n
          \n
        • Edge node (Scaleway): $0.15\/M token (offline, bulk)<\/li>\n
        • GCP Vertex AI: $1.0\/M token (prefill optimized)<\/li>\n
        • AWS Bedrock: $1.5\/M token (managed, con SLA)<\/li>\n<\/ul>\n
          L’orchestrazione intelligente cerca di mandare il 60% del traffico su edge (basso costo), 30% su GCP (buon rapporto costo\/latenza), fallback AWS (10%, emergenza).<\/p>\n
          FAQ<\/h2>\n
          Cosa succede se il planner LLM stesso fallisce o \u00e8 lento?<\/h3>\n
          Il planner \u00e8 asincrono e non critico al percorso richiesta. Genera strategie ogni 5-10 minuti per il prossimo batch di richieste. Se \u00e8 down, usiamo l’ultima strategia buona cached. Il DRL agent edge non dipende dal planner, decide in tempo reale autonomamente.<\/p>\n
          Come implemento prefix caching su multi-cloud senza infrangere data residency?<\/h3>\n
          Prefix cache resta locale al cluster dove il modello gira. Se una richiesta va da Italia a GCP EU-West, i KV cache di sistema prompt stanno in EU-West, non tornano in Italia. Per sessioni critiche (customer-sensitive), cache encrypted with customer-specific key.<\/p>\n
          Quale modello scegliere per edge inference?<\/h3>\n
          Meta Llama 3.1 8B Instruct \u00e8 un modello linguistico multilingue con 8 miliardi di parametri ottimizzato per dialogue, addestrato su oltre 15 trilioni di token, supera molti modelli open-source e closed-source sui benchmark industriali, usa supervised fine-tuning e reinforcement learning con feedback umano per sicurezza e utilit\u00e0, rendendolo ideale per edge deployment per via della dimensione compatta e inference efficiente<\/cite>. Per vision \u00e8 meglio Qwen2.5-VL-7B.<\/p>\n
          Come monitorare se agenti stanno spillando su cloud quando dovrebbero restare su edge?<\/h3>\n
          Setup: ogni richiesta ha tag `intended_location` e `actual_location`. Prometheus metric `inference_location_mismatch_total` track deviazioni. Alert se tasso di spillover > 20% (significa topologia\/DRL non ottimizzati).<\/p>\n
          Quanto tempo richiede implementare questo stack?<\/h3>\n
          Se hai gi\u00e0 Kubernetes multi-cluster: 4-6 settimane per setup base (topology config, KV-orchestrator deployment, DRL training). Se parti da zero: 3-4 mesi. Il 70% del tempo \u00e8 tuning e testing, 30% coding.<\/p>\n
          Conclusione<\/h2>\n
          AI-Native Infrastructure 2026 non \u00e8 optional\u2014\u00e8 la baseline per stare competitivi. Se ancora fai inference su VM generiche o con orchestration statica, stai bruciando soldi e regali latenza ai competitor.<\/p>\n
          Nel mio percorso quest’anno ho visto provider piccoli (Scaleway, DigitalOcean) e grandi (AWS, GCP) tutti fare lo stesso movimento: costruire cloud pensati per AI, non web apps. Se usi ancora infrastruttura 2.0, adesso \u00e8 il tempo di pianificare la migrazione.<\/p>\n
          La chiave non \u00e8 usare il provider pi\u00f9 grande, ma orchestrare intelligentemente tra pi\u00f9 provider, usando LLM per decisioni long-term e DRL per adattamento real-time. E soprattutto: monitora tutto, perch\u00e9 ogni ms di latency costa in conversioni e customer retention.<\/p>\n
          Domanda per te:<\/strong> Stai gi\u00e0 usando multi-cloud orchestration per agenti, o ancora deployando su singolo provider? Fammelo sapere nei commenti\u2014sono curioso di come altri affrontano questo.<\/p>\n","protected":false},"excerpt":{"rendered":"
          Guida pratica per implementare AI-Native Infrastructure 2026: Cloud 3.0 Architecture, Multi-Cloud Orchestration con LLM planner e DRL agents, Low-Latency Edge Inference per agenti autonomi. Architetture, codice e case study reali.<\/p>\n","protected":false},"author":1,"featured_media":5353,"comment_status":"","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"_seopress_robots_primary_cat":"","_seopress_titles_title":"AI-Native Hosting 2026: Cloud 3.0 & Multi-Cloud Orchestration | Guida","_seopress_titles_desc":"Implementa AI-Native Hosting Infrastructure 2026: Cloud 3.0 Architecture, Multi-Cloud Orchestration, Edge Inference. Guida pratica con codice, topologie e case study.","_seopress_robots_index":"","footnotes":""},"categories":[3],"tags":[412,465,407,839,849,672],"class_list":["post-5352","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-hosting","tag-ai-orchestration","tag-cloud-3-0","tag-edge-computing","tag-hosting-infrastructure","tag-kubernetes","tag-llm-inference"],"_links":{"self":[{"href":"https:\/\/darioiannascoli.it\/blog\/wp-json\/wp\/v2\/posts\/5352","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=5352"}],"version-history":[{"count":0,"href":"https:\/\/darioiannascoli.it\/blog\/wp-json\/wp\/v2\/posts\/5352\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/darioiannascoli.it\/blog\/wp-json\/wp\/v2\/media\/5353"}],"wp:attachment":[{"href":"https:\/\/darioiannascoli.it\/blog\/wp-json\/wp\/v2\/media?parent=5352"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/darioiannascoli.it\/blog\/wp-json\/wp\/v2\/categories?post=5352"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/darioiannascoli.it\/blog\/wp-json\/wp\/v2\/tags?post=5352"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}