{"id":361,"date":"2026-08-29T07:31:06","date_gmt":"2026-08-29T07:31:06","guid":{"rendered":"https:\/\/www.mydoctorsnow.com\/blog\/?p=361"},"modified":"2026-08-29T07:31:06","modified_gmt":"2026-08-29T07:31:06","slug":"enterprise-cloud-cost-optimization-strategies-to-reduce-operational-waste","status":"publish","type":"post","link":"https:\/\/www.mydoctorsnow.com\/blog\/index.php\/2026\/08\/29\/enterprise-cloud-cost-optimization-strategies-to-reduce-operational-waste\/","title":{"rendered":"Enterprise Cloud Cost Optimization Strategies to Reduce Operational Waste"},"content":{"rendered":"\n
\"\"<\/figure>\n\n\n\n

Introduction<\/h2>\n\n\n\n

Operating containerized applications at scale introduces complex visibility challenges. As microservices spin up and down across distributed nodes, traditional server-centric monitoring models fail to capture short-lived workload behaviors. Cloud operations teams need dynamic systems that can automatically discover new endpoints, scrape metrics, and provide real-time operational insights.Implementing robust Kubernetes Monitoring with Prometheus solves this visibility challenge by providing a pull-based metrics collection model designed specifically for dynamic container environments. Understanding how to collect, analyze, and alert on system metrics is essential for maintaining infrastructure reliability. For platform engineers looking to refine their broader operational strategies, exploring proven cloud operations management<\/a> <\/strong>techniques helps bridge the gap between simple telemetry and actionable system management.<\/p>\n\n\n\n

What is Kubernetes Monitoring with Prometheus?<\/h2>\n\n\n\n

Prometheus is an open-source, time-series database and monitoring tool engineered specifically for dynamic cloud-native environments. Originally created at SoundCloud and maintained by the Cloud Native Computing Foundation (CNCF), it relies on a pull-based HTTP mechanism to scrape metrics from exposed targets.<\/p>\n\n\n\n

When applied to Kubernetes, Prometheus automatically discovers infrastructure targets like API servers, node components, and pod containers using native Kubernetes API integration. Rather than waiting for applications to push logs or events, Prometheus queries HTTP endpoints at fixed intervals to gather key performance indicators.<\/p>\n\n\n\n

+-----------------------------------------------------------------+\n|                        KUBERNETES CLUSTER                       |\n|                                                                 |\n|   +-------------------+    Scrapes    +---------------------+   |\n|   | Prometheus Server | ------------> | Pod \/ Node \/ Service|   |\n|   +---------+---------+    Metrics    +---------------------+   |\n|             |                                                   |\n|             | Evaluates Rules                                   |\n|             v                                                   |\n|   +-------------------+   Fires Alerts +--------------------+   |\n|   |   Alertmanager    | -------------> | Slack \/ PagerDuty  |   |\n|   +-------------------+                +--------------------+   |\n+-----------------------------------------------------------------+\n<\/code><\/pre>\n\n\n\n
This model provides continuous insight into system health, capacity usage, and runtime anomalies without overloading microservice architectures with heavy agent processes.<\/p>\n\n\n\n
How Does Prometheus Work in Kubernetes?<\/h2>\n\n\n\n
Prometheus relies on a structured, modular operational flow to gather, store, and act on metric data across your cluster.<\/p>\n\n\n\n
    \n
  1. Service Discovery:<\/strong> Prometheus queries the Kubernetes API server continuously to discover running nodes, services, ingress controllers, and individual pods.<\/li>\n\n\n\n
  2. Scraping Metrics:<\/strong> At configured intervals (the scrape interval), Prometheus sends HTTP GET requests to target \/metrics<\/code> endpoints.<\/li>\n\n\n\n
  3. Data Ingestion:<\/strong> Scraped metrics are stored in a local time-series database (TSDB) using key-value pairs paired with precise timestamps.<\/li>\n\n\n\n
  4. Rule Evaluation:<\/strong> Prometheus continuously runs PromQL (Prometheus Query Language) expressions against the stored data to compute rates, aggregations, and alerting thresholds.<\/li>\n\n\n\n
  5. Alert Routing:<\/strong> When alerting conditions are met, Prometheus pushes alerts to Alertmanager, which handles deduplication, grouping, silence windows, and notifications to external channels.<\/li>\n<\/ol>\n\n\n\n
    Core Components of Prometheus Architecture<\/h2>\n\n\n\n
    Managing Prometheus requires a solid understanding of its core architectural modules:<\/p>\n\n\n\n
      \n
    • Prometheus Server:<\/strong> The central engine that handles service discovery, metric scraping, time-series storage, and PromQL query execution.<\/li>\n\n\n\n
    • Exporters:<\/strong> Light HTTP servers that translate non-Prometheus metrics into standard Prometheus formats. Examples include Node Exporter<\/em> for host-level OS metrics and kube-state-metrics<\/em> for Kubernetes object status.<\/li>\n\n\n\n
    • Pushgateway:<\/strong> A temporary intermediary buffer that allows short-lived or batch jobs to push metrics before exiting, allowing Prometheus to scrape them asynchronously.<\/li>\n\n\n\n
    • Alertmanager:<\/strong> The dedicated alerting engine that receives alerts from the server, suppresses noise, groups related events, and dispatches notices via webhooks, email, or paging services.<\/li>\n\n\n\n
    • Client Libraries:<\/strong> Application-level SDKs (Go, Python, Java, Node.js) that developers use to instrument custom business logic metrics.<\/li>\n<\/ul>\n\n\n\n
      Role of AWS, Azure, and GCP<\/h2>\n\n\n\n
      Managed Kubernetes services simplify control-plane management, but metric collection strategies vary slightly across major cloud infrastructure providers.<\/p>\n\n\n\n
      Feature \/ Cloud<\/strong><\/td>AWS (EKS)<\/strong><\/td>Azure (AKS)<\/strong><\/td>GCP (GKE)<\/strong><\/td><\/tr><\/thead>
      Native Observability Integrations<\/strong><\/td>Amazon Managed Prometheus (AMP) & CloudWatch<\/td>Azure Monitor Container Insights & Managed Prometheus<\/td>Google Cloud Managed Service for Prometheus<\/td><\/tr>
      Control Plane Metric Access<\/strong><\/td>Exposed via API Server endpoints requiring IAM authentication<\/td>Integrated into Azure Monitor metrics stream<\/td>Fully managed system metrics available out-of-the-box<\/td><\/tr>
      Storage & Persistence Considerations<\/strong><\/td>Attach Amazon EBS volumes or remote write to AMP<\/td>Attach Azure Managed Disks or stream to Azure Workspace<\/td>Store locally on persistent disks or use GCP Managed Collector<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
      Cloud Operations and Infrastructure Automation<\/h2>\n\n\n\n
      Integrating observability into modern CloudOps requires treating monitoring configuration as code. Manually managing Prometheus scrape targets or alert rules leads to drift, missing coverage, and operational overhead.<\/p>\n\n\n\n
      Infrastructure as Code (IaC) tools like Terraform should provision underlying storage and network policies, while Helm or the Prometheus Operator<\/strong> manage runtime deployments within the cluster.<\/p>\n\n\n\n
      YAML<\/p>\n\n\n\n
      # Example: ServiceMonitor CRD deployed via GitOps workflows\napiVersion: monitoring.coreos.com\/v1\nkind: ServiceMonitor\nmetadata:\n  name: app-backend-monitor\n  namespace: monitoring\nspec:\n  selector:\n    matchLabels:\n      app: backend-api\n  endpoints:\n  - port: metrics\n    interval: 15s\n<\/code><\/pre>\n\n\n\n
      Using GitOps engines (such as ArgoCD or Flux) ensures that any changes to Alertmanager configs, custom alerting rules, or dashboard definitions are audited, version-controlled, and automatically synced across multi-cluster environments.<\/p>\n\n\n\n
      Metrics, Observability, and Reliability<\/h2>\n\n\n\n
      A healthy Kubernetes monitoring system tracks data across four key infrastructure layers:<\/p>\n\n\n\n
        \n
      • Cluster Infrastructure:<\/strong> CPU, memory, disk I\/O, and network usage per node, captured via Node Exporter.<\/li>\n\n\n\n
      • Kubernetes Objects:<\/strong> Deployment status, replica readiness, crash loop counts, and pod restart frequencies provided by kube-state-metrics<\/code>.<\/li>\n\n\n\n
      • Container Runtime:<\/strong> Resource limits versus actual usage scraped directly from cAdvisor on the Kubelet.<\/li>\n\n\n\n
      • Application Layer:<\/strong> Custom business metrics like request latency, error rates, and queue depth exposed via application instrumentation.<\/li>\n<\/ul>\n\n\n\n
                                          +-----------------------+\n                                  |  Application Metrics  |\n                                  | (Latency, Requests)   |\n                                  +-----------+-----------+\n                                              |\n                                  +-----------v-----------+\n                                  |   Container Metrics   |\n                                  |  (Limits vs Real Use) |\n                                  +-----------+-----------+\n                                              |\n                                  +-----------v-----------+\n                                  |   Kubernetes State    |\n                                  | (Restarts, Replicas)  |\n                                  +-----------+-----------+\n                                              |\n                                  +-----------v-----------+\n                                  | Infrastructure Node   |\n                                  | (Host CPU, Disk, Net) |\n                                  +-----------------------+\n<\/code><\/pre>\n\n\n\n
        To establish actionable reliability practices, align metrics with the Four Golden Signals<\/strong>:<\/p>\n\n\n\n
          \n
        1. Latency:<\/strong> Time taken to service a request (distinguishing between successful and failed requests).<\/li>\n\n\n\n
        2. Traffic:<\/strong> Demand placed on the system, such as HTTP requests per second.<\/li>\n\n\n\n
        3. Errors:<\/strong> Rate of requests that fail, either explicitly (5xx codes) or implicitly.<\/li>\n\n\n\n
        4. Saturation:<\/strong> Measure of system fullness, emphasizing resource constraints like CPU memory limits.<\/li>\n<\/ol>\n\n\n\n
          Security and Governance for Monitoring<\/h2>\n\n\n\n
          Monitoring systems have broad access across your cluster, making security a high priority.<\/p>\n\n\n\n
            \n
          • Role-Based Access Control (RBAC):<\/strong> Restrict Prometheus service accounts to read-only access for cluster resources. Use distinct namespaces for monitoring components.<\/li>\n\n\n\n
          • Network Policies:<\/strong> Limit ingress access to metrics endpoints. Only the Prometheus server should be authorized to scrape application pods on designated port ranges.<\/li>\n\n\n\n
          • Secrets Management:<\/strong> Secure credentials, TLS certificates, and webhook tokens used by Alertmanager using Kubernetes Secrets or external secret stores like HashiCorp Vault.<\/li>\n\n\n\n
          • Scrape Endpoints Encryption:<\/strong> Enable Mutual TLS (mTLS) for metrics scraping across cluster nodes to prevent sensitive telemetry data from leaking in transit over unencrypted internal networks.<\/li>\n<\/ul>\n\n\n\n
            Best Practices for Production Monitoring<\/h2>\n\n\n\n
              \n
            1. Leverage Prometheus Operator:<\/strong> Deploy the Prometheus Operator to manage instances, scrape configurations, and alerting rules using Custom Resource Definitions (CRDs) like ServiceMonitor<\/code> and PrometheusRule<\/code>.<\/li>\n\n\n\n
            2. Avoid High Cardinality Labels:<\/strong> Do not use user IDs, IP addresses, or unformatted UUIDs as metric labels. High cardinality rapidly consumes RAM and degrades query performance.<\/li>\n\n\n\n
            3. Set Meaningful Resource Requests\/Limits:<\/strong> Ensure your Prometheus pod has sufficient guaranteed RAM and CPU to prevent Out-Of-Memory (OOM) kills during heavy query processing.<\/li>\n\n\n\n
            4. Decouple Storage using Remote Write:<\/strong> Offload long-term historical metric data to external scalable backends (such as Thanos, Cortex, or VictoriaMetrics) to keep your local Prometheus TSDB lightweight.<\/li>\n\n\n\n
            5. Alert on Symptoms, Not Causes:<\/strong> Trigger actionable alerts on user-impacting issues (e.g., high error rates) rather than transient system states (e.g., brief spike in CPU usage).<\/li>\n\n\n\n
            6. Implement Scrape Interval Tiering:<\/strong> Use faster scrape intervals (10s\u201315s) for critical application workloads and longer intervals (30s\u201360s) for slow-changing infrastructure components.<\/li>\n\n\n\n
            7. Filter Unused Metrics:<\/strong> Drop unnecessary metrics at scrape time using metric_relabel_configs<\/code> to minimize ingestion costs and storage usage.<\/li>\n<\/ol>\n\n\n\n
              Common Implementation Mistakes<\/h2>\n\n\n\n
                \n
              • Treating Prometheus as a Long-Term Database:<\/strong> Storing months of raw telemetry directly on a local disk often causes disk exhaustion and slow query responses.<\/li>\n\n\n\n
              • Ignoring Kubelet and cAdvisor Limits:<\/strong> Failing to monitor container memory limits alongside request values leads to silent OOMKilled events.<\/li>\n\n\n\n
              • Unrestricted Alerting:<\/strong> Configuring hundreds of low-priority alerts causes alert fatigue, leading on-call engineers to miss critical production warnings.<\/li>\n\n\n\n
              • Overlooking Rule Performance:<\/strong> Writing inefficient PromQL queries with wide time ranges can stall the Prometheus engine during execution.<\/li>\n\n\n\n
              • Hardcoding Configurations:<\/strong> Manually editing global config maps instead of using automated pipelines or operator CRDs creates operational drift and consistency errors.<\/li>\n<\/ul>\n\n\n\n
                Real-World Use Cases<\/h2>\n\n\n\n
                  \n
                • Dynamic Autoscaling (HPA):<\/strong> Exposing custom application metrics (like message queue depth) through Prometheus metrics APIs allows the Horizontal Pod Autoscaler to adjust pod counts dynamically.<\/li>\n\n\n\n
                • Microservices Incident Response:<\/strong> Correlating elevated HTTP 5xx rates with recent deployment events helps on-call engineers identify buggy rollouts immediately.<\/li>\n\n\n\n
                • Capacity Planning:<\/strong> Analyzing node CPU and memory utilization trends over time allows platform teams to rightsizing cluster node pools and reduce cloud infrastructure costs.<\/li>\n\n\n\n
                • Multi-Tenant Cost Allocation:<\/strong> Tracking pod resource usage by namespace provides clear data to attribute infrastructure costs across different internal teams.<\/li>\n<\/ul>\n\n\n\n
                  Operational Challenges and Limitations<\/h2>\n\n\n\n
                  While powerful, operating Prometheus natively introduces specific challenges:<\/p>\n\n\n\n
                    \n
                  • Horizontal Scaling Constraints:<\/strong> A single Prometheus server scales vertically. Handling millions of active series requires deploying remote storage engines like Thanos or Cortex.<\/li>\n\n\n\n
                  • Lack of Native Global View:<\/strong> Prometheus operates locally within a cluster. Aggregating data across dozens of multi-cloud Kubernetes clusters requires centralized query federation.<\/li>\n\n\n\n
                  • Storage Consumption:<\/strong> High metric ingestion rates consume local storage rapidly, demanding careful persistent volume management and retention policy tuning.<\/li>\n\n\n\n
                  • No Built-in Long-Term Historical Analysis:<\/strong> By default, Prometheus is optimized for short-term operational monitoring rather than multi-year historical trend reporting.<\/li>\n<\/ul>\n\n\n\n
                    Step-by-Step Implementation Guide<\/h2>\n\n\n\n
                    Follow this practical deployment strategy to establish monitoring in a production Kubernetes cluster.<\/p>\n\n\n\n
                      \n
                    1. Deploy Prometheus Operator:<\/strong> Install the kube-prometheus-stack via Helm to bootstrap Prometheus, Alertmanager, Grafana, and standard node exporters.<\/li>\n\n\n\n
                    2. Configure Storage Retention:<\/strong> Define local persistent storage claims and set an appropriate retention window (e.g., 7 to 14 days).<\/li>\n\n\n\n
                    3. Expose Application Endpoints:<\/strong> Instrument workloads using Prometheus client SDKs to expose an internal \/metrics<\/code> endpoint.<\/li>\n\n\n\n
                    4. Create ServiceMonitors:<\/strong> Apply ServiceMonitor<\/code> manifests targeting application labels to instruct Prometheus to automatically discover and pull metrics.<\/li>\n\n\n\n
                    5. Define Alerting Rules:<\/strong> Deploy PrometheusRule<\/code> resources containing validated PromQL queries for key SLIs like error rates and pod crash loops.<\/li>\n\n\n\n
                    6. Configure Alertmanager Routing:<\/strong> Set up notification channels (PagerDuty, Slack, Webhooks) with appropriate deduplication and grouping windows.<\/li>\n\n\n\n
                    7. Build Grafana Dashboards:<\/strong> Connect Grafana to the Prometheus data source and import standard cluster dashboards for quick operational visualization.<\/li>\n\n\n\n
                    8. Validate Setup with Chaos Testing:<\/strong> Simulate pod failures and high traffic loads to confirm alerts trigger correctly and dashboards reflect changes accurately.<\/li>\n<\/ol>\n\n\n\n
                      Future Trends in Kubernetes Monitoring<\/h2>\n\n\n\n
                      Observability ecosystems continue to evolve beyond basic metric scraping:<\/p>\n\n\n\n
                        \n
                      • OpenTelemetry Standardization:<\/strong> OpenTelemetry is becoming the universal collector for traces, logs, and metrics, integrating seamlessly with Prometheus storage engines.<\/li>\n\n\n\n
                      • AIOps and Anomaly Detection:<\/strong> Machine learning pipelines process Prometheus metric feeds to automatically establish baselines and detect anomalies without manual thresholding.<\/li>\n\n\n\n
                      • eBPF-Driven Telemetry:<\/strong> Kernel-level observability tools collect system network and performance metrics automatically, eliminating the need to manually instrument code.<\/li>\n\n\n\n
                      • FinOps and Cost Observability:<\/strong> Tools like OpenCost integrate with Prometheus metrics to provide real-time cost visibility down to individual pods and namespaces.<\/li>\n<\/ul>\n\n\n\n
                        Frequently Asked Questions<\/h2>\n\n\n\n
                          \n
                        1. How does Kubernetes Monitoring with Prometheus collect metric data from application pods?<\/strong><\/li>\n<\/ol>\n\n\n\n
                          Prometheus uses a pull-based model to collect metrics. It periodically queries HTTP metric endpoints (typically \/metrics<\/code>) exposed by targeted pods, discovering endpoints dynamically via integration with the Kubernetes API server.<\/p>\n\n\n\n
                            \n
                          1. What is the difference between Prometheus and Grafana?<\/strong><\/li>\n<\/ol>\n\n\n\n
                            Prometheus functions as the time-series database, collection engine, and alerting tool, while Grafana acts as the visualization layer that queries Prometheus to build custom dashboards and graphs.<\/p>\n\n\n\n
                              \n
                            1. Why is kube-state-metrics required alongside Node Exporter?<\/strong><\/li>\n<\/ol>\n\n\n\n
                              Node Exporter gathers host-level hardware and operating system metrics (like CPU and disk usage), whereas kube-state-metrics listens to the Kubernetes API server to generate metrics about the health status of deployment objects, pods, and jobs.<\/p>\n\n\n\n
                                \n
                              1. How long should metric data be retained inside local Prometheus storage?<\/strong><\/li>\n<\/ol>\n\n\n\n
                                Local Prometheus storage is typically configured to retain data for 7 to 14 days. For long-term historical storage, telemetry should be offloaded to remote storage solutions like Thanos, Cortex, or VictoriaMetrics.<\/p>\n\n\n\n
                                  \n
                                1. Can Prometheus handle multi-cluster Kubernetes environments natively?<\/strong><\/li>\n<\/ol>\n\n\n\n
                                  A single Prometheus instance is designed to monitor local targets within its cluster. Multi-cluster monitoring requires central query engines, federation, or long-term remote write solutions like Thanos.<\/p>\n\n\n\n
                                    \n
                                  1. What is high cardinality, and why does it impact Prometheus performance?<\/strong><\/li>\n<\/ol>\n\n\n\n
                                    High cardinality occurs when metric labels contain a vast or infinite set of unique values (such as user IDs or timestamps). This drastically increases memory consumption and slows down PromQL query evaluation.<\/p>\n\n\n\n
                                      \n
                                    1. How does Prometheus handle short-lived batch jobs or CronJobs?<\/strong><\/li>\n<\/ol>\n\n\n\n
                                      Short-lived jobs push their telemetry to a Pushgateway before exiting. Prometheus then scrapes those metrics from the Pushgateway asynchronously.<\/p>\n\n\n\n
                                        \n
                                      1. How does Prometheus Operator simplify cluster management?<\/strong><\/li>\n<\/ol>\n\n\n\n
                                        Prometheus Operator automates the deployment, configuration, and management of Prometheus instances using native Kubernetes Custom Resource Definitions (CRDs) like ServiceMonitor<\/code> and PrometheusRule<\/code>.<\/p>\n\n\n\n
                                          \n
                                        1. What are the four golden signals in Kubernetes monitoring?<\/strong><\/li>\n<\/ol>\n\n\n\n
                                          The four golden signals of monitoring are Latency, Traffic, Errors, and Saturation. Tracking these provides a reliable measure of overall application health and user experience.<\/p>\n\n\n\n
                                            \n
                                          1. How do managed services like Amazon Managed Prometheus differ from self-hosted Prometheus?<\/strong><\/li>\n<\/ol>\n\n\n\n
                                            Managed services handle storage scaling, high availability, maintenance, and underlying server patching, allowing cloud operations teams to focus on writing alerts and dashboards rather than managing monitoring infrastructure.<\/p>\n\n\n\n
                                            Conclusion<\/h2>\n\n\n\n
                                            Implementing a robust strategy for Kubernetes Monitoring with Prometheus<\/strong> is vital for securing visibility across modern cloud environments. By leveraging dynamic service discovery, building structured PromQL queries, and implementing symptom-based alerting rules, platform engineering teams can identify anomalies before they result in application downtime.Success relies on applying operational discipline: avoid metric label overload, secure your scrape endpoints, and enforce infrastructure as code across your deployment pipelines. As your container footprint grows, extending Prometheus with scalable remote storage engines ensures your observability infrastructure remains resilient, performant, and cost-effective.<\/p>\n","protected":false},"excerpt":{"rendered":"
                                            Introduction Operating containerized applications at scale introduces complex visibility challenges. As microservices spin up and down across distributed nodes, traditional server-centric monitoring models fail to capture short-lived workload behaviors. Cloud operations teams need dynamic systems that can automatically discover new endpoints, scrape metrics, and provide real-time operational insights.Implementing robust Kubernetes Monitoring with Prometheus solves this […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[258,324,322,76,323],"class_list":["post-361","post","type-post","status-publish","format-standard","hentry","category-uncategorized","tag-cloudcostoptimization","tag-cloudinfrastructure","tag-cloudops","tag-devops","tag-finops"],"_links":{"self":[{"href":"https:\/\/www.mydoctorsnow.com\/blog\/index.php\/wp-json\/wp\/v2\/posts\/361","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.mydoctorsnow.com\/blog\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.mydoctorsnow.com\/blog\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.mydoctorsnow.com\/blog\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.mydoctorsnow.com\/blog\/index.php\/wp-json\/wp\/v2\/comments?post=361"}],"version-history":[{"count":1,"href":"https:\/\/www.mydoctorsnow.com\/blog\/index.php\/wp-json\/wp\/v2\/posts\/361\/revisions"}],"predecessor-version":[{"id":363,"href":"https:\/\/www.mydoctorsnow.com\/blog\/index.php\/wp-json\/wp\/v2\/posts\/361\/revisions\/363"}],"wp:attachment":[{"href":"https:\/\/www.mydoctorsnow.com\/blog\/index.php\/wp-json\/wp\/v2\/media?parent=361"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.mydoctorsnow.com\/blog\/index.php\/wp-json\/wp\/v2\/categories?post=361"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.mydoctorsnow.com\/blog\/index.php\/wp-json\/wp\/v2\/tags?post=361"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}