Add edge docs

docs/reference/architecture/hosts_vms.md

@@ -13,58 +13,49 @@ products:
 
 # Hosts and VMs environments
 
-On host or virtual machine environments, deploy local, per-host OpenTelemetry Collector instances, here referred to as OTel Collector in Agent Mode.
+On host or virtual machine environments, deploy local, per-host OpenTelemetry Collector instances at these [edge](index.md#understanding-edge-deployment) host or VMs where your applications are running.
 
-![VM-Edge](../images/arch-vm-edge.png)
-
-These collectors have two main purposes:
+Collectors deployed on these edge environments have two main purposes:
 
 1.  The collection of local logs and infrastructure metrics. Refer to [this sample config file](https://github.com/elastic/elastic-agent/blob/main/internal/pkg/otel/samples/linux/managed_otlp/platformlogs_hostmetrics.yml) for recommended Collector receiver configurations for hostmetrics and logs.
-2.  Enriching application telemetry from OTel SDKs that run within the instrumented applications on corresponding hosts with resource information.
-
-## Deployment scenarios
-
-See the recommended architectures per Elastic deployment scenarios:
+2.  Enriching application telemetry from OTel SDKs with the corresponding hosts resource attributes.
 
 :::{note}
-Elastic's Observability solution is technically compatible with edge setups that are fully based on contrib OTel components as long as the ingestion path follows the recommendations outlined in the following sections.
+Elastic Observability is technically compatible with edge setups that are fully based on contrib OTel components as long as the ingestion path follows the recommendations outlined in the following sections.
 :::
 
-### Elastic Cloud Serverless
-
-{{serverless-full}} provides a [Managed OTLP Endpoint](/reference/motlp.md) for ingestion of OpenTelemetry data.
-
-![VM-Serverless](../images/arch-vm-serverless.png)
+## Deployment scenarios
 
-Users can send their OTel data from the edge setup in OTel-native format through OTLP without any additional requirements for self-managed preprocessing of data.
+The following sections outline the recommended architectures for different Elastic deployment scenarios.
 
-### Elastic Cloud Hosted
+### {{serverless-full}}
 
-As of Elastic Stack version 9.0 on {{ech}} (ECH), you need to run a self-hosted EDOT Collector in Gateway Mode to ingest OTel data from the edge setup in OTel-native format into the Elastic-hosted {{es}}.
+{{serverless-full}} provides a [Managed OTLP Endpoint](/reference/motlp.md) for ingestion of OpenTelemetry data.
 
-![VM-ECH](../images/arch-vm-ech.png)
+![VM-Serverless](../images/host-serverless.png)
 
-The EDOT Collector in Gateway mode enriches and pre-aggregates the data for a seamless experience in the Elastic Observability solution before ingesting it directly into {{es}}.
+Users can send data direct from the Collectors or SDKs deployed on the edge environment through OTLP without any additional requirements for managing an ingestion layer.
 
-If required, users can build their custom, EDOT-like Collector
-[following these instructions](elastic-agent://reference/edot-collector/custom-collector.md).
+### {{ech}}
+```{applies_to}
+ess:
+stack: preview 9.2
+```
 
-:::{note}
-The EDOT Gateway Collector does not send data through Elastic's Integration / APM Server on ECH to ingest data into {{es}}.
-:::
+{{ech}} provides a [Managed OTLP Endpoint](/reference/motlp.md) for ingestion of OpenTelemetry data. Users can send data direct from the Collectors or SDKs deployed on the edge environment through OTLP without any additional requirements for managing an ingestion layer.
 
-:::{important}
-If self-managing an EDOT Gateway is not a valid option for you, refer to [Elastic's classic ingestion path for OTel data on ECH](docs-content://solutions/observability/apm/use-opentelemetry-with-apm.md).
-:::
+![VM-ech](../images/host-ech.png)
 
 ### Self-managed
 
-In a self-managed deployment scenario, you need to host an EDOT Collector in Gateway mode that pre-processes and ingests OTel data from the edge setup into the self-managed Elastic Stack.
+In a self-managed Elastic deployment, we recommend running an EDOT Collector in gateway mode as a unified ingestion layer for OTLP telemetry from OpenTelemetry collectors or SDKs running at the edge. This gateway can receive all signals (logs, metrics and traces), apply processing as needed, and cover the same use cases that previously required components like APM Server or Logstash.
+
+Depending on your scalability and durability needs, this can be a single collector that scales horizontally, or a chain of collectors where each tier handles a specific concern. For high availability and stronger durability guarantees, you can insert Kafka between tiers so that ingestion is buffered and resilient to downstream outages.
 
-![VM-self-managed](../images/arch-vm-self-managed.png)
+![VM-self-managed](../images/host-self-managed.png)
 
 :::{note}
-Compared to [Elastic's classic ingestion paths](docs-content://solutions/observability/apm/use-opentelemetry-with-apm.md) for OTel data, with the EDOT Gateway Collector there is no need for an APM Server anymore. 
+Compared to [Elastic's classic ingestion paths](docs-content://solutions/observability/apm/use-opentelemetry-with-apm.md) for OTel data, with the EDOT Collector in gateway mode there is no need for {{product.apm-server}} anymore. 
 
-Refer to [EDOT data streams compared to classic APM](../compatibility/data-streams.md) for a detailed comparison of data streams, mappings, and storage models.
+Refer to [data streams compared to classic {{product.apm}}](../compatibility/data-streams.md) for a detailed comparison of data streams, mappings, and storage models.
 :::

docs/reference/architecture/index.md

@@ -18,3 +18,53 @@ The following sections outline the recommended architectures for Elastic Distrib
 - [Hosts and VMs](hosts_vms.md)
 - [Kubernetes](k8s.md)
 
+## Understanding edge deployment
+
+In the context of OpenTelemetry architecture, 'edge' refers to the environment where applications are running: individual hosts, virtual machines, or as daemon sets on Kubernetes nodes. Collectors deployed in these environments perform two primary functions:
+
+1. They gather logs, infrastructure metrics, application traces, profiles, and other telemetry from the local environment.
+2. They enrich application telemetry from OpenTelemetry SDKs running on the same host or node with resource metadata, such as host information and Kubernetes attributes.
+
+### Vendor-neutral collector deployments on edge environments
+
+You can use any OpenTelemetry Collector distribution at the edge, including:
+
+- The contrib OpenTelemetry Collector.
+- Custom-built Collector distributions.
+- The {{edot}} Collector.
+- Any shipper capable of sending valid OTLP data.
+
+The only requirement is that collectors deployed on edge environments send data using valid OpenTelemetry Protocol (OTLP) to {{ecloud}} (using managed OTLP endpoint) or to the OTLP receiver of a gateway EDOT collector for self-managed deployments.
+
+While any OTLP-compatible collector works at the edge, using EDOT provides a more streamlined experience with:
+
+- Preconfigured components optimized for {{product.observability}}.
+- Curated receivers and processors for common use cases.
+- Simplified setup and configuration.
+
+## Understanding the {{product.observability}} backend [understanding-the-elastic-observability-backend]
+
+The {{product.observability}} backend is the ingestion and storage layer where your telemetry data is processed, indexed, and made available for analysis. This includes:
+
+- **{{es}}**: Stores and indexes your telemetry data.
+- **{{kib}}**: Provides visualization and analysis interfaces.
+- **Managed OTLP Endpoint** (for {{serverless-full}} and {{ech}}): A managed ingestion service that receives OTLP data.
+- **Gateway Collector** (for self-managed, ECE, and ECK): An EDOT Collector running in gateway mode that serves as the ingestion layer.
+
+:::{note}
+When a Collector in gateway mode is deployed, it is considered part of the {{product.observability}} backend, not part of the edge deployment. The Collector in gateway mode sits between your edge collectors and {{es}}, acting as a centralized ingestion and preprocessing layer.
+:::
+
+### When gateway mode is required
+
+The need for an EDOT Collector in gateway mode as part of your Elastic backend depends on your deployment type:
+
+**{{serverless-full}} and {{ech}}**: Edge collectors can send OTLP data directly to the [Managed OTLP Endpoint](/reference/motlp.md) without requiring a self-managed Gateway Collector. The Managed OTLP Endpoint provides a fully managed ingestion layer as part of the Elastic backend. You can optionally deploy an EDOT Collector in gateway mode as part of your edge environment if you need additional processing before data reaches the Managed OTLP Endpoint.
+
+**Self-managed, ECE, and ECK deployments**: An EDOT Collector in gateway mode is **required as part of your {{product.observability}} backend**. This Gateway Collector exposes the OTLP endpoint that edge collectors send data to, and handles essential preprocessing, including:
+
+- Metrics aggregation for traces and logs, which improves {{product.apm}} UI performance with lower latency.
+- Format conversion for optimal storage in {{es}}.
+
+For detailed information about Agent and Gateway modes and their specific requirements, refer to the [deployment mode documentation](elastic-agent://reference/edot-collector/modes.md).
+

docs/reference/architecture/k8s.md

@@ -11,81 +11,84 @@
   - id: edot-collector
 ---
 
-# Kubernetes Environments
+# Kubernetes environments
 
-The recommended OTel architecture for Kubernetes clusters includes a set of OpenTelemetry collectors in different forms. The following diagram shows the different forms:
+In Kubernetes environments, deploy OpenTelemetry Collectors as [edge](index.md#understanding-edge-deployment) collectors within your cluster where your applications are running. The recommended architecture includes different types of collectors deployed as various Kubernetes resource types (DaemonSets, Deployments) to handle specific collection needs.
 
-![K8s-Cluster](../images/arch-k8s-cluster.png)
+Collectors deployed in these edge environments have several main purposes:
 
-## Daemon form
+1. The collection of node-level logs and infrastructure metrics through DaemonSet collectors running on each node.
+2. The collection of cluster-level metrics through a dedicated Cluster collector.
+3. Enriching application telemetry from OTel SDKs with corresponding host and Kubernetes resource attributes.
+4. Centralizing data through a gateway collector before sending to the Elastic backend.
 
-The Collector in Daemon form is deployed on each Kubernetes node to collect nodes-local logs and host metrics.
+## Types of collectors
 
-The daemon collector also receives telemetry from applications instrumented with OTel SDKs and running on corresponding nodes.
+The recommended OTel architecture for Kubernetes clusters includes a set of OpenTelemetry collectors in different forms.
+
+### DaemonSet collectors
+
+The Collector as a DaemonSet resource kind, deploys an instance on each Kubernetes node as an [edge collector](index.md#understanding-edge-deployment) (close to your data sources) to collect node-local logs and host metrics.
+
+The DaemonSet collectors also can funnel and enrich telemetry from applications instrumented with OTel SDKs and running on corresponding nodes.
 
 That Collector enriches the application telemetry with resource information such as host and Kubernetes metadata.
 
-All data is then being sent through OTLP to the OTel or EDOT Gateway Collector.
+All data is then sent through OTLP to the gateway Collector running in the cluster.
 
-## Cluster form
+### Cluster collector
 
-The Collector in Cluster form collects Kubernetes cluster-level metrics and sends them to the OTel or EDOT Gateway Collector using OTLP.
+The Cluster collector is a Deployment resource kind that collects Kubernetes cluster-level metrics and sends them to the gateway Collector using OTLP.
 
-## Gateway form
+This instance of the collector helps with collecting cluster level metrics which otherwise would be duplicated by the DaemonSet instances.
 
-The OTel or EDOT Collector in Gateway form gathers the OTel data from all other collectors and ingests it into the Elastic backend.
+### Gateway collector (on edge)
 
-For self-managed and {{ech}} deployment models the Gateway Collector does some additional pre-processing of data.
+The gateway Collector deployed in the Kubernetes cluster centralizes OTel data from the DaemonSet and Cluster collectors. This gateway collector runs as part of your edge environment, not as part of the Elastic backend. It can be any OpenTelemetry Collector distribution as long as it forwards data using OTLP to the appropriate backend endpoint:
+
+- For {{serverless-full}} and {{ech}}: Sends OTLP data to the Managed OTLP Endpoint.
+- For self-managed, ECE, and ECK: Sends OTLP data to an EDOT Collector running in gateway mode on the backend side (refer to [backend architecture](index.md#understanding-the-elastic-observability-backend)).
 
 ## Deployment scenarios
 
-See the recommended architectures per Elastic deployment scenarios:
+The following sections outline the recommended architectures for different Elastic deployment scenarios.
 
 ::::{note}
-Elastic's Observability solution is technically compatible with setups that are fully based on contrib OTel components, as long as the ingestion path follows the recommendations outlined in following sub-sections for the different Elastic deployment options.
+{{product.observability}} is technically compatible with setups that are fully based on contrib OTel components, as long as the ingestion path follows the recommendations outlined in following sections for the different Elastic deployment options.
 ::::
 
-### Elastic Cloud Serverless
+### {{serverless-full}}
 
 {{serverless-full}} provides a [Managed OTLP Endpoint](/reference/motlp.md) for ingestion of OpenTelemetry data.
 
-![K8s-Serverless](../images/arch-k8s-serverless.png)
-
-For a Kubernetes setup, that means the Gateway Collector passes through the OTel data in native format using the OTLP protocol to the managed OTLP endpoint. There is no need for the Gateway Collector to do any Elastic-specific pre-processing.
-
-### Elastic Cloud Hosted
+![K8s-Serverless](../images/k8s-serverless.png)
 
-With {{ech}} (ECH), OTel data is being directly ingested into the Elastic-hosted {{es}} instance.
+For a Kubernetes setup, the gateway Collector in your cluster sends OTLP data directly to the Managed OTLP Endpoint. There is no need for an EDOT gateway collector on the backend side. You can optionally deploy an EDOT Collector in gateway mode as part of your edge environment if you need additional processing before data reaches the Managed OTLP Endpoint.
 
-![K8s-ECH](../images/arch-k8s-ech.png)
+### {{ech}}
+```{applies_to}
+ess:
+stack: preview 9.2
+```
 
-The Gateway Collector needs to do some preprocessing, aggregation of metrics and, finally, it uses the {{es}} exporter to ingest data into ECH.
+{{ech}} provides a [Managed OTLP Endpoint](/reference/motlp.md) for ingestion of OpenTelemetry data.
 
-While the Daemon and Cluster collectors, as well as the OTel SDKs, can stay fully vendor agnostic or upstream, the Gateway Collector needs to be either an EDOT Collector or a [custom, EDOT-like Collector](elastic-agent://reference/edot-collector/custom-collector.md) containing the
-[required components and pre-processing pipelines](elastic-agent://reference/edot-collector/config/default-config-k8s.md#direct-ingestion-into-elasticsearch).
+For a Kubernetes setup, the gateway Collector in your cluster sends OTLP data directly to the Managed OTLP Endpoint. There is no need for an EDOT gateway collector on the backend side.
 
-If required, users can build their custom, EDOT-like Collector [following these instructions](elastic-agent://reference/edot-collector/custom-collector.md).
-
-::::{note}
-The EDOT Gateway Collector does not send data through Elastic's Integration / APM Server on ECH to ingest data into {{es}}.
-::::
-
-::::{important}
-If self-managing an EDOT Gateway is not a valid option for you, refer to [Elastic's classic ingestion path for OTel data on ECH](docs-content://solutions/observability/apm/use-opentelemetry-with-apm.md).
-::::
+![K8s-ech](../images/k8s-ech.png)
 
 ### Self-managed
 
-With a self-managed scenario the Gateway Collector ingests data directly into the self-managed {{es}} instance.
+With a self-managed deployment, you need an EDOT Collector running in gateway mode as part of your {{product.observability}} backend (not in the Kubernetes cluster). This backend gateway collector receives OTLP data from the Kubernetes gateway collector and ingests it into {{es}}.
 
-![K8s-self-managed](../images/arch-k8s-self-managed.png)
+![K8s-self-managed](../images/k8s-self-managed.png)
 
-The Gateway Collector does some preprocessing and aggregation of OTel data before ingesting it into {{es}}.
+The backend gateway Collector processes {{product.apm}} data and logs to improve latency on solution UIs before ingesting into {{es}}.
 
-While the Daemon and Cluster collectors, as well as the OTel SDKs, can stay fully vendor agnostic or upstream, the Gateway Collector needs to be either an EDOT Collector or a [custom, EDOT-like Collector](elastic-agent://reference/edot-collector/custom-collector.md) containing the [required components and pre-processing pipelines](elastic-agent://reference/edot-collector/config/default-config-k8s.md#direct-ingestion-into-elasticsearch).
+The Kubernetes cluster components (DaemonSet collectors, Cluster collectors, gateway collector, and OTel SDKs) can all use fully vendor-agnostic or upstream OpenTelemetry components. Only the backend gateway Collector needs to be either an EDOT Collector or a [custom, EDOT-like Collector](elastic-agent://reference/edot-collector/custom-collector.md) containing the [required components and preprocessing pipelines](elastic-agent://reference/edot-collector/config/default-config-k8s.md#direct-ingestion-into-elasticsearch).
 
 ::::{note}
-Compared to [Elastic's classic ingestion paths](docs-content://solutions/observability/apm/use-opentelemetry-with-apm.md) for OTel data, with the EDOT Gateway Collector there is no need for an APM Server anymore.
+Compared to [Elastic's classic ingestion paths](docs-content://solutions/observability/apm/use-opentelemetry-with-apm.md) for OTel data, with the EDOT gateway Collector there is no need for {{product.apm-server}} anymore.
 
-Refer to [EDOT data streams compared to classic APM](../compatibility/data-streams.md) for a detailed comparison of data streams, mappings, and storage models.
+Refer to [EDOT data streams compared to classic {{product.apm}}](../compatibility/data-streams.md) for a detailed comparison of data streams, mappings, and storage models.
 ::::