diff --git a/.gitignore b/.gitignore
index 808fd66..0ea9107 100644
--- a/.gitignore
+++ b/.gitignore
@@ -31,4 +31,4 @@
/.nb-gradle/
/working_directory/
-**/configuration-server/users.db
+spring-petclinic-docker-demo-gradle/configuration-server/users.db
diff --git a/README.md b/README.md
index bae1bff..79c0d58 100644
--- a/README.md
+++ b/README.md
@@ -2,3 +2,7 @@
This project provides a comprehensive demonstration of the capabilities of the inspectIT Ocelot Java agent using different infrastructure architectures.
A detailed description of each existing scenario can be found in the [documentation](https://inspectit.github.io/inspectit-ocelot/docs/getting-started/docker-examples).
+
+You can find the docker demo based on the [Spring PetClinic](https://github.com/spring-projects/spring-petclinic) in the [`spring-petclinic-docker-demo`](./spring-petclinic-docker-demo) directory.
+
+The kubernetes demo based on the [trading demo application](https://github.com/inspectIT/trading-demo-application) can be found in the [`trading-application-k8s-demo`](./trading-application-k8s-demo) directory.
diff --git a/.env b/spring-petclinic-docker-demo/.env
similarity index 100%
rename from .env
rename to spring-petclinic-docker-demo/.env
diff --git a/spring-petclinic-docker-demo/README.md b/spring-petclinic-docker-demo/README.md
new file mode 100644
index 0000000..ac54dc0
--- /dev/null
+++ b/spring-petclinic-docker-demo/README.md
@@ -0,0 +1,3 @@
+# inspectIT Ocelot - Spring Petclinic Docker Demo
+
+You can find the documentation of this demo in the [official inspectIT Ocelot documentation](https://inspectit.github.io/inspectit-ocelot/docs/getting-started/docker-examples).
\ No newline at end of file
diff --git a/build.gradle b/spring-petclinic-docker-demo/build.gradle
similarity index 87%
rename from build.gradle
rename to spring-petclinic-docker-demo/build.gradle
index c19af51..006b847 100644
--- a/build.gradle
+++ b/spring-petclinic-docker-demo/build.gradle
@@ -6,7 +6,7 @@ task setVersionForDockerCompose(type: Copy) {
task packageDemo(type: Zip) {
dependsOn 'setVersionForDockerCompose'
- archiveName = "inspectit-ocelot-demo-${version}.zip"
+ archiveName = "inspectit-ocelot-spring-petclinic-docker-demo-${version}.zip"
destinationDir = file(buildDir)
from (projectDir){
diff --git a/configuration-server/agent_mappings.yaml b/spring-petclinic-docker-demo/configuration-server/agent_mappings.yaml
similarity index 100%
rename from configuration-server/agent_mappings.yaml
rename to spring-petclinic-docker-demo/configuration-server/agent_mappings.yaml
diff --git a/configuration-server/files/all/general.yml b/spring-petclinic-docker-demo/configuration-server/files/all/general.yml
similarity index 100%
rename from configuration-server/files/all/general.yml
rename to spring-petclinic-docker-demo/configuration-server/files/all/general.yml
diff --git a/configuration-server/files/all/hsqldb-sql-extraction.yml b/spring-petclinic-docker-demo/configuration-server/files/all/hsqldb-sql-extraction.yml
similarity index 100%
rename from configuration-server/files/all/hsqldb-sql-extraction.yml
rename to spring-petclinic-docker-demo/configuration-server/files/all/hsqldb-sql-extraction.yml
diff --git a/configuration-server/files/all/parametrize-eureka-paths.yml b/spring-petclinic-docker-demo/configuration-server/files/all/parametrize-eureka-paths.yml
similarity index 100%
rename from configuration-server/files/all/parametrize-eureka-paths.yml
rename to spring-petclinic-docker-demo/configuration-server/files/all/parametrize-eureka-paths.yml
diff --git a/configuration-server/files/all/validatePetType.yml b/spring-petclinic-docker-demo/configuration-server/files/all/validatePetType.yml
similarity index 100%
rename from configuration-server/files/all/validatePetType.yml
rename to spring-petclinic-docker-demo/configuration-server/files/all/validatePetType.yml
diff --git a/docker-compose-influxdb-jaeger.yml b/spring-petclinic-docker-demo/docker-compose-influxdb-jaeger.yml
similarity index 100%
rename from docker-compose-influxdb-jaeger.yml
rename to spring-petclinic-docker-demo/docker-compose-influxdb-jaeger.yml
diff --git a/docker-compose-influxdb-zipkin.yml b/spring-petclinic-docker-demo/docker-compose-influxdb-zipkin.yml
similarity index 100%
rename from docker-compose-influxdb-zipkin.yml
rename to spring-petclinic-docker-demo/docker-compose-influxdb-zipkin.yml
diff --git a/docker-compose-prometheus-jaeger.yml b/spring-petclinic-docker-demo/docker-compose-prometheus-jaeger.yml
similarity index 100%
rename from docker-compose-prometheus-jaeger.yml
rename to spring-petclinic-docker-demo/docker-compose-prometheus-jaeger.yml
diff --git a/docker-compose-wavefront-zipkin.yml b/spring-petclinic-docker-demo/docker-compose-wavefront-zipkin.yml
similarity index 100%
rename from docker-compose-wavefront-zipkin.yml
rename to spring-petclinic-docker-demo/docker-compose-wavefront-zipkin.yml
diff --git a/grafana/marketplace/dashboard-mapping.txt b/spring-petclinic-docker-demo/grafana/marketplace/dashboard-mapping.txt
similarity index 100%
rename from grafana/marketplace/dashboard-mapping.txt
rename to spring-petclinic-docker-demo/grafana/marketplace/dashboard-mapping.txt
diff --git a/grafana/marketplace/influx/http.json b/spring-petclinic-docker-demo/grafana/marketplace/influx/http.json
similarity index 100%
rename from grafana/marketplace/influx/http.json
rename to spring-petclinic-docker-demo/grafana/marketplace/influx/http.json
diff --git a/grafana/marketplace/influx/jvm.json b/spring-petclinic-docker-demo/grafana/marketplace/influx/jvm.json
similarity index 100%
rename from grafana/marketplace/influx/jvm.json
rename to spring-petclinic-docker-demo/grafana/marketplace/influx/jvm.json
diff --git a/grafana/marketplace/influx/selfmonitoring.json b/spring-petclinic-docker-demo/grafana/marketplace/influx/selfmonitoring.json
similarity index 100%
rename from grafana/marketplace/influx/selfmonitoring.json
rename to spring-petclinic-docker-demo/grafana/marketplace/influx/selfmonitoring.json
diff --git a/grafana/marketplace/influx/servicegraph.json b/spring-petclinic-docker-demo/grafana/marketplace/influx/servicegraph.json
similarity index 100%
rename from grafana/marketplace/influx/servicegraph.json
rename to spring-petclinic-docker-demo/grafana/marketplace/influx/servicegraph.json
diff --git a/grafana/marketplace/influx/system.json b/spring-petclinic-docker-demo/grafana/marketplace/influx/system.json
similarity index 100%
rename from grafana/marketplace/influx/system.json
rename to spring-petclinic-docker-demo/grafana/marketplace/influx/system.json
diff --git a/grafana/marketplace/prometheus/http.json b/spring-petclinic-docker-demo/grafana/marketplace/prometheus/http.json
similarity index 100%
rename from grafana/marketplace/prometheus/http.json
rename to spring-petclinic-docker-demo/grafana/marketplace/prometheus/http.json
diff --git a/grafana/marketplace/prometheus/jvm.json b/spring-petclinic-docker-demo/grafana/marketplace/prometheus/jvm.json
similarity index 100%
rename from grafana/marketplace/prometheus/jvm.json
rename to spring-petclinic-docker-demo/grafana/marketplace/prometheus/jvm.json
diff --git a/grafana/marketplace/prometheus/selfmonitoring.json b/spring-petclinic-docker-demo/grafana/marketplace/prometheus/selfmonitoring.json
similarity index 100%
rename from grafana/marketplace/prometheus/selfmonitoring.json
rename to spring-petclinic-docker-demo/grafana/marketplace/prometheus/selfmonitoring.json
diff --git a/grafana/marketplace/prometheus/servicegraph.json b/spring-petclinic-docker-demo/grafana/marketplace/prometheus/servicegraph.json
similarity index 100%
rename from grafana/marketplace/prometheus/servicegraph.json
rename to spring-petclinic-docker-demo/grafana/marketplace/prometheus/servicegraph.json
diff --git a/grafana/marketplace/prometheus/system.json b/spring-petclinic-docker-demo/grafana/marketplace/prometheus/system.json
similarity index 100%
rename from grafana/marketplace/prometheus/system.json
rename to spring-petclinic-docker-demo/grafana/marketplace/prometheus/system.json
diff --git a/grafana/provisioning/home-dashboard/home.json b/spring-petclinic-docker-demo/grafana/provisioning/home-dashboard/home.json
similarity index 100%
rename from grafana/provisioning/home-dashboard/home.json
rename to spring-petclinic-docker-demo/grafana/provisioning/home-dashboard/home.json
diff --git a/grafana/provisioning/influxdb/dashboards/agent/http-overview-influxql.json b/spring-petclinic-docker-demo/grafana/provisioning/influxdb/dashboards/agent/http-overview-influxql.json
similarity index 100%
rename from grafana/provisioning/influxdb/dashboards/agent/http-overview-influxql.json
rename to spring-petclinic-docker-demo/grafana/provisioning/influxdb/dashboards/agent/http-overview-influxql.json
diff --git a/grafana/provisioning/influxdb/dashboards/agent/jvm-metrics.json b/spring-petclinic-docker-demo/grafana/provisioning/influxdb/dashboards/agent/jvm-metrics.json
similarity index 100%
rename from grafana/provisioning/influxdb/dashboards/agent/jvm-metrics.json
rename to spring-petclinic-docker-demo/grafana/provisioning/influxdb/dashboards/agent/jvm-metrics.json
diff --git a/grafana/provisioning/influxdb/dashboards/agent/self-monitoring.json b/spring-petclinic-docker-demo/grafana/provisioning/influxdb/dashboards/agent/self-monitoring.json
similarity index 100%
rename from grafana/provisioning/influxdb/dashboards/agent/self-monitoring.json
rename to spring-petclinic-docker-demo/grafana/provisioning/influxdb/dashboards/agent/self-monitoring.json
diff --git a/grafana/provisioning/influxdb/dashboards/agent/service-graph-influxql.json b/spring-petclinic-docker-demo/grafana/provisioning/influxdb/dashboards/agent/service-graph-influxql.json
similarity index 100%
rename from grafana/provisioning/influxdb/dashboards/agent/service-graph-influxql.json
rename to spring-petclinic-docker-demo/grafana/provisioning/influxdb/dashboards/agent/service-graph-influxql.json
diff --git a/grafana/provisioning/influxdb/dashboards/agent/system-metrics.json b/spring-petclinic-docker-demo/grafana/provisioning/influxdb/dashboards/agent/system-metrics.json
similarity index 100%
rename from grafana/provisioning/influxdb/dashboards/agent/system-metrics.json
rename to spring-petclinic-docker-demo/grafana/provisioning/influxdb/dashboards/agent/system-metrics.json
diff --git a/grafana/provisioning/influxdb/dashboards/dashboards.yml b/spring-petclinic-docker-demo/grafana/provisioning/influxdb/dashboards/dashboards.yml
similarity index 100%
rename from grafana/provisioning/influxdb/dashboards/dashboards.yml
rename to spring-petclinic-docker-demo/grafana/provisioning/influxdb/dashboards/dashboards.yml
diff --git a/grafana/provisioning/influxdb/dashboards/eum-server/Beacons.json b/spring-petclinic-docker-demo/grafana/provisioning/influxdb/dashboards/eum-server/Beacons.json
similarity index 100%
rename from grafana/provisioning/influxdb/dashboards/eum-server/Beacons.json
rename to spring-petclinic-docker-demo/grafana/provisioning/influxdb/dashboards/eum-server/Beacons.json
diff --git a/grafana/provisioning/influxdb/dashboards/eum-server/Traces.json b/spring-petclinic-docker-demo/grafana/provisioning/influxdb/dashboards/eum-server/Traces.json
similarity index 100%
rename from grafana/provisioning/influxdb/dashboards/eum-server/Traces.json
rename to spring-petclinic-docker-demo/grafana/provisioning/influxdb/dashboards/eum-server/Traces.json
diff --git a/grafana/provisioning/influxdb/datasources/influxdb.yml b/spring-petclinic-docker-demo/grafana/provisioning/influxdb/datasources/influxdb.yml
similarity index 100%
rename from grafana/provisioning/influxdb/datasources/influxdb.yml
rename to spring-petclinic-docker-demo/grafana/provisioning/influxdb/datasources/influxdb.yml
diff --git a/grafana/provisioning/prometheus/dashboards/agent/http-overview.json b/spring-petclinic-docker-demo/grafana/provisioning/prometheus/dashboards/agent/http-overview.json
similarity index 100%
rename from grafana/provisioning/prometheus/dashboards/agent/http-overview.json
rename to spring-petclinic-docker-demo/grafana/provisioning/prometheus/dashboards/agent/http-overview.json
diff --git a/grafana/provisioning/prometheus/dashboards/agent/jvm-metrics.json b/spring-petclinic-docker-demo/grafana/provisioning/prometheus/dashboards/agent/jvm-metrics.json
similarity index 100%
rename from grafana/provisioning/prometheus/dashboards/agent/jvm-metrics.json
rename to spring-petclinic-docker-demo/grafana/provisioning/prometheus/dashboards/agent/jvm-metrics.json
diff --git a/grafana/provisioning/prometheus/dashboards/agent/self-monitoring.json b/spring-petclinic-docker-demo/grafana/provisioning/prometheus/dashboards/agent/self-monitoring.json
similarity index 100%
rename from grafana/provisioning/prometheus/dashboards/agent/self-monitoring.json
rename to spring-petclinic-docker-demo/grafana/provisioning/prometheus/dashboards/agent/self-monitoring.json
diff --git a/grafana/provisioning/prometheus/dashboards/agent/service-graph.json b/spring-petclinic-docker-demo/grafana/provisioning/prometheus/dashboards/agent/service-graph.json
similarity index 100%
rename from grafana/provisioning/prometheus/dashboards/agent/service-graph.json
rename to spring-petclinic-docker-demo/grafana/provisioning/prometheus/dashboards/agent/service-graph.json
diff --git a/grafana/provisioning/prometheus/dashboards/agent/system-metrics.json b/spring-petclinic-docker-demo/grafana/provisioning/prometheus/dashboards/agent/system-metrics.json
similarity index 100%
rename from grafana/provisioning/prometheus/dashboards/agent/system-metrics.json
rename to spring-petclinic-docker-demo/grafana/provisioning/prometheus/dashboards/agent/system-metrics.json
diff --git a/grafana/provisioning/prometheus/dashboards/dashboards.yml b/spring-petclinic-docker-demo/grafana/provisioning/prometheus/dashboards/dashboards.yml
similarity index 100%
rename from grafana/provisioning/prometheus/dashboards/dashboards.yml
rename to spring-petclinic-docker-demo/grafana/provisioning/prometheus/dashboards/dashboards.yml
diff --git a/grafana/provisioning/prometheus/datasources/prometheus.yml b/spring-petclinic-docker-demo/grafana/provisioning/prometheus/datasources/prometheus.yml
similarity index 100%
rename from grafana/provisioning/prometheus/datasources/prometheus.yml
rename to spring-petclinic-docker-demo/grafana/provisioning/prometheus/datasources/prometheus.yml
diff --git a/influx/continous-queries.iql b/spring-petclinic-docker-demo/influx/continous-queries.iql
similarity index 100%
rename from influx/continous-queries.iql
rename to spring-petclinic-docker-demo/influx/continous-queries.iql
diff --git a/load/Dockerfile b/spring-petclinic-docker-demo/load/Dockerfile
similarity index 100%
rename from load/Dockerfile
rename to spring-petclinic-docker-demo/load/Dockerfile
diff --git a/load/docker-entrypoint.sh b/spring-petclinic-docker-demo/load/docker-entrypoint.sh
similarity index 100%
rename from load/docker-entrypoint.sh
rename to spring-petclinic-docker-demo/load/docker-entrypoint.sh
diff --git a/load/load-script.yml b/spring-petclinic-docker-demo/load/load-script.yml
similarity index 100%
rename from load/load-script.yml
rename to spring-petclinic-docker-demo/load/load-script.yml
diff --git a/prometheus/prometheus.yml b/spring-petclinic-docker-demo/prometheus/prometheus.yml
similarity index 100%
rename from prometheus/prometheus.yml
rename to spring-petclinic-docker-demo/prometheus/prometheus.yml
diff --git a/telegraf/telegraf-influx.conf b/spring-petclinic-docker-demo/telegraf/telegraf-influx.conf
similarity index 100%
rename from telegraf/telegraf-influx.conf
rename to spring-petclinic-docker-demo/telegraf/telegraf-influx.conf
diff --git a/telegraf/telegraf-wavefront.conf b/spring-petclinic-docker-demo/telegraf/telegraf-wavefront.conf
similarity index 100%
rename from telegraf/telegraf-wavefront.conf
rename to spring-petclinic-docker-demo/telegraf/telegraf-wavefront.conf
diff --git a/trading-application-k8s-demo/README.md b/trading-application-k8s-demo/README.md
new file mode 100644
index 0000000..473b9dd
--- /dev/null
+++ b/trading-application-k8s-demo/README.md
@@ -0,0 +1,651 @@
+# Trading-Demo in Kubernetes instrumented with inspectIT Ocelot and OpenTelemetry Collector
+
+This demo deploys the [trading demo application](https://github.com/inspectIT/trading-demo-application) to Kubernetes and adds instrumentation with [inspectIT Ocelot](https://github.com/inspectIT/inspectit-ocelot) and the [OpenTelemetry Collector](https://github.com/open-telemetry/opentelemetry-collector) and exports traces to [Jaeger](https://www.jaegertracing.io/). The inspectIT Ocelot Agent and OpenTelemetry Collector Agent Sidecar injection is done with the [OpenTelemetry Operator](https://github.com/open-telemetry/opentelemetry-operator).
+
+This tutorial based on the official [inspectIT Ocelot installation documentation](https://inspectit.github.io/inspectit-ocelot/docs/next/getting-started/installation#using-the-agent-with-kubernetes).
+
+
+
+
+
+> Please **note** that we are showcasing to deploy the OpenTelemetry Collector Agent as a sidecar for illustrative purposes. The sidecar in this demo just receives, batches, and exports the traces. Imagine a use case in which a lot of traces received by the OpenTelemetry Collector should be filtered out, e.g., when a lot of readiness or liveliness probes are sent. In this scenario, it may be good to filter out these traces as close to the instrumented application as possible before sending the final traces over the network to the Collector deployment or to a Jaeger backend. Further, the OpenTelemetry Collector `deployment` also just received, batches, and exports the traces to Jaeger. Imagine a use case where we receive traces from different use cases. In this case, standardization of the traces using the OpenTelemetry Collector is a good way before sending the traces to the desired backend.
+>
+> However, the alternative to deploy the trading demo application without the sidecar and directly export to the OpenTelemetry Collector deployment (or event to the Jaeger backend) may be more appropriate in the given context.
+
+## 1. Requirements
+
+1. Install and deploy the [OpenTelemetry Operator](https://github.com/open-telemetry/opentelemetry-operator) as described in the official [readme](https://github.com/open-telemetry/opentelemetry-operator#getting-started).
+ 1. Install the [cert-manager](https://cert-manager.io/docs/installation/)
+
+ ```shell
+ kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.7.1/cert-manager.yaml
+ ```
+
+ 2. Install [Ingress](https://kubernetes.github.io/ingress-nginx/deploy/)
+
+ ```shell
+ kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.1.2/deploy/static/provider/cloud/deploy.yaml
+ ```
+
+ 3. Install the operator using the following command. Please note that this will install the latest version of it:
+
+ ```shell
+ kubectl apply -f https://github.com/open-telemetry/opentelemetry-operator/releases/latest/download/opentelemetry-operator.yaml
+ ```
+
+ By adjusting the URL to a different GitHub release, a specific version of the operator can be used:
+
+ ```shell
+ kubectl apply -f https://github.com/open-telemetry/opentelemetry-operator/releases/download/v{version}/opentelemetry-operator.yaml
+ ```
+ * If you follow the instruction, it automatically deploys the OpenTelemetryCollector to the `opentelemetry-operator-system` namespace
+2. Create the namespace `trading-demo` in which the [Trading Demo Application](#3-deploy-the-trading-demo-application), the [inspectIT Ocelot Instrumentation](#1-deploy-inspectit-ocelot-agent-as-an-instrumentation), and the [OpenTelemetry Collector Agent Sidecar](#2-deploy-the-opentelemetry-collector-agent-sidecar) will be deployed
+
+ ```shell
+ kubectl create namespace trading-demo
+ ```
+## 2. Install and deploy [Jaeger](https://www.jaegertracing.io/) in the namespace `monitoring`
+
+You can install Jaeger either via the [Jaeger Operator](https://www.jaegertracing.io/docs/1.32/operator/) or as a [standalone all-in-one solution](#2-alternatively-install-the-standalone-version).
+
+### 1. Using the Jaeger Operator
+
+1. Install the [Jaeger Operator](https://www.jaegertracing.io/docs/1.32/operator/) using the following commands. Please note that his will install the latest version of it:
+
+ ```shell
+ # create the namespace that Jaeger will live in
+ kubectl create namespace monitoring
+
+ kubectl create -f https://github.com/jaegertracing/jaeger-operator/releases/download/v1.32.0/jaeger-operator.yaml -n monitoring
+ ```
+
+2. Deploy`Jaeger-all-in-one` in the `monitoring` namespace
+
+ 1. Create `jaeger-all-in-one.yaml` file
+ ```yaml
+ apiVersion: jaegertracing.io/v1
+ kind: Jaeger
+ metadata:
+ name: jaeger
+ ```
+
+ 2. Deploy `Jaeger-all-in-one`
+
+ ```shell
+ kubectl apply -f ./jaeger-all-in-one-standalone.yaml -n monitoring
+ ```
+
+3. Alternatively, deploy via
+
+ ```shell
+ cat << EOF | kubectl apply -n monitoring -f -
+ apiVersion: jaegertracing.io/v1
+ kind: Jaeger
+ metadata:
+ name: jaeger
+ ```
+### 2. Alternatively, install the standalone version
+If you don't want to install Jaeger via the Jaeger Operator, you can also deploy an all-in-one solution specified in `./jaeger/jaeger-all-in-one-standalone.yaml`, which is from https://github.com/hashfyre/otel-k8s and adjusted to the needs of this demo
+
+1. Deploy Jaeger
+ ```shell
+ # create the namespace that Jaeger will live in
+ kubectl create namespace monitoring
+
+ # deploy Jaeger
+ kubectl apply -f ./jaeger/jaeger-all-in-one-standalone.yaml
+ ```
+
+2. Verify the deployment
+ ```shell
+ kubectl get all -n monitoring
+ ```
+
+ * the result should look similar to this if you deployed the standalone version:
+ ```shell
+ NAME READY STATUS RESTARTS AGE
+ pod/jaeger-7594d99f98-szdll 1/1 Running 1 (3d22h ago) 5d3h
+
+ NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
+ service/jaeger ClusterIP None 16686/TCP,14268/TCP,14250/TCP 5d18h
+
+ NAME READY UP-TO-DATE AVAILABLE AGE
+ deployment.apps/jaeger 1/1 1 1 5d18h
+
+ NAME DESIRED CURRENT READY AGE
+ replicaset.apps/jaeger-7594d99f98 1 1 1 5d3h
+ replicaset.apps/jaeger-84c88d694f 0 0 0 5d18h
+ ```
+
+3. Use `port-forward` to access the Jaeger UI on localhost on port 16686 ([http://localhost:16686](http://localhost:16686))
+
+ > open a new terminal
+
+ ```shell
+ # for the Jaeger deployed with the Jaeger Operator
+ kubectl port-forward -n monitoring service/jaeger-query 16686
+
+ # for the standalone Jaeger-all-in-one deployment
+ kubectl port-forward -n monitoring service/jaeger 16686
+ ```
+
+## 2. Deploy OpenTelemetry Collector
+
+In this example, we will deploy the OpenTelemetryCollector as a `deployment` that receives traces either from the OpenTelemetry Collector Agent `sidecar` or from the trading demo application directly.
+
+### 1. The OpenTelemetry Collector as `Deployment`
+
+The OpenTelemetry Collector as `Deployment` will be used to receive traces sent via Jaeger or OTLP, process the traces, and export them to our Jaeger collector and to system out (logging).
+
+* The file `./otel-collector.yaml` deploys the OpenTelemetry Collector as a `Deployment` in the namespace `otel`.
+
+ 1. Deploy the OpenTelemetry Collector `deployment` in the namespace `otel`
+
+ ```shel
+ kubectl apply -f ./otel/otel-collector.yaml
+ ```
+
+ - the `Service` opens the relevant ports for receiver and exporter
+
+ - the `ConfigMap` specifies the [configuration](https://opentelemetry.io/docs/collector/configuration/)
+ * in the demo, we receive Jaeger and OTLP traces and export them to Jaeger and logging. For processors, we only use `batch` and `memory_limiter`.
+
+ * the `Deployment` deploys the OpenTelemetry Collector with respective ports and the `ConfigMap` as configuration
+
+ ```yaml
+ apiVersion: v1
+ kind: Service
+ metadata:
+ name: otel-collector
+ namespace: otel
+ labels:
+ app: opentelemetry
+ component: otel-collector
+ spec:
+ ports:
+ - name: otlp-grpc # Default endpoint for OpenTelemetry gRPC receiver.
+ port: 4317
+ protocol: TCP
+ targetPort: 4317
+ - name: otlp-http # Default endpoint for OpenTelemetry HTTP receiver.
+ port: 4318
+ protocol: TCP
+ targetPort: 4318
+ - name: metrics # Default endpoint for querying metrics.
+ port: 8888
+ - name: prometheus # Prometheus exporter
+ protocol: TCP
+ port: 8889
+ targetPort: 8889
+ - name: jaeger-ace # Jaeger ACE receiver
+ port: 6831
+ protocol: TCP
+ - name: jaeger-inspectit # Jaeger inspectIT Ocelot receiver
+ port: 14268
+ targetPort: 14268
+ protocol: TCP
+ selector:
+ component: otel-collector
+ ---
+ apiVersion: v1
+ kind: ConfigMap
+ metadata:
+ name: otel-collector-conf
+ namespace: otel
+ labels:
+ app: opentelemetry
+ component: otel-collector-conf
+ data:
+ otel-collector-config: |
+ receivers:
+ otlp:
+ protocols:
+ grpc:
+ http:
+ jaeger:
+ protocols:
+ thrift_compact:
+ thrift_binary:
+ thrift_http:
+ processors:
+ batch:
+ memory_limiter:
+ # 80% of maximum memory up to 2G
+ limit_mib: 1500
+ # 25% of limit up to 2G
+ spike_limit_mib: 512
+ check_interval: 5s
+ extensions:
+ zpages: {}
+ memory_ballast:
+ # Memory Ballast size should be max 1/3 to 1/2 of memory.
+ size_mib: 683
+ exporters:
+ jaeger:
+ endpoint: "jaeger.monitoring:14250"
+ tls:
+ insecure: true
+ logging:
+ service:
+ extensions: [zpages, memory_ballast]
+ pipelines:
+ traces/1:
+ receivers: [otlp, jaeger]
+ processors: [memory_limiter, batch]
+ exporters: [jaeger, logging]
+ telemetry:
+ logs:
+ level: "info"
+ ---
+ apiVersion: apps/v1
+ kind: Deployment
+ metadata:
+ name: otel-collector
+ namespace: otel
+ labels:
+ app: opentelemetry
+ component: otel-collector
+ spec:
+ selector:
+ matchLabels:
+ app: opentelemetry
+ component: otel-collector
+ minReadySeconds: 5
+ progressDeadlineSeconds: 120
+ replicas: 1
+ template:
+ metadata:
+ labels:
+ app: opentelemetry
+ component: otel-collector
+ spec:
+ containers:
+ - command:
+ - "/otelcol"
+ - "--config=/conf/otel-collector-config.yaml"
+ image: otel/opentelemetry-collector:0.47.0
+ name: otel-collector
+ resources:
+ limits:
+ cpu: 1
+ memory: 2Gi
+ requests:
+ cpu: 200m
+ memory: 400Mi
+ ports:
+ - containerPort: 55679 # Default endpoint for ZPages.
+ - containerPort: 4317 # Default endpoint for OpenTelemetry receiver.
+ - containerPort: 14250 # Default endpoint for Jaeger gRPC receiver.
+ - containerPort: 14268 # Default endpoint for Jaeger HTTP receiver.
+ - containerPort: 9411 # Default endpoint for Zipkin receiver.
+ - containerPort: 8888 # Default endpoint for querying metrics.
+ volumeMounts:
+ - name: otel-collector-config-vol
+ mountPath: /conf
+ volumes:
+ - configMap:
+ name: otel-collector-conf
+ items:
+ - key: otel-collector-config
+ path: otel-collector-config.yaml
+ name: otel-collector-config-vol
+ ```
+
+ 2. Verify the deployment
+ ```shell
+ kubectl get all -n otel
+ ```
+
+ * the result should look similar to this:
+ ```shel
+ NAME READY STATUS RESTARTS AGE
+ pod/otel-collector-5698989fd-w4ddz 1/1 Running 0 15s
+
+ NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
+ service/otel-collector ClusterIP 10.107.64.43 4317/TCP,4318/TCP,8888/TCP,8889/TCP,6831/TCP,14268/TCP 15s
+
+ NAME READY UP-TO-DATE AVAILABLE AGE
+ deployment.apps/otel-collector 1/1 1 1 15s
+
+ NAME DESIRED CURRENT READY AGE
+ replicaset.apps/otel-collector-5698989fd 1 1 1 15s
+ ```
+
+### 2. Deploy the OpenTelemetry Collector Agent `sidecar`
+
+> **Important**: If you do not want to inject the OpenTelemetry Collector Agent as a `sidecar` and directly send the traces to the [OpenTelemetry Collector deployment](#1-the-opentelemetry-collector-as--deployment), you can skip this step and re-configure Jaeger endpoint url in the [inspectIT Ocelot Configuration Server](#2-deploy-the-inspectit-ocelot-configuration-server).
+
+We will inject an OpenTelemetry Collector as a `sidecar` into the trading demo application using the [OpenTelemetry Operator](https://github.com/open-telemetry/opentelemetry-operator#sidecar-injection).
+
+> **Important:** if you have not yet created the namespace `trading-demo`, do so! (`kubectl create namespace trading-demo`)
+
+* The file located in `./otel/otelcol-agent-sidecar.yaml` deploys an `OpenTelemetryCollector` with the `mode: sidecar`
+
+ 1. Deploy the OpenTelemetry Collector Agent `sidecar` in the namespace `trading-demo`
+
+ ```shel
+ kubectl apply -f ./otel/otelcol-agent-sidecar.yaml -n trading-demo
+ ```
+
+ > **Important: ** the OpenTelemetry Collector Agent sidecar must be deployed in the same namespace as the target application, which is `trading-demo` for this tutorial.
+
+ - we configure the OpenTelemetry Collector sidecar to receive traces via OTLP and Jaeger and export them to the [OpenTelemetry Collector deployment](#1-the-opentelemetry-collector-as--deployment) and to the system out (logging). We again only use the `memory_limiter` and `batch` exporter
+
+ ```yaml
+ ---
+ apiVersion: opentelemetry.io/v1alpha1
+ kind: OpenTelemetryCollector
+ metadata:
+ name: otelcol-sidecar
+ spec:
+ mode: sidecar
+ config: |
+ receivers:
+ otlp:
+ protocols:
+ grpc:
+ http:
+ jaeger:
+ protocols:
+ grpc:
+ thrift_binary:
+ thrift_http:
+ thrift_compact:
+ exporters:
+ otlp:
+ endpoint: "otel-collector.otel.svc.cluster.local:4317"
+ tls:
+ insecure: true
+ logging:
+ processors:
+ batch:
+ memory_limiter:
+ # 80% of maximum memory up to 2G
+ limit_mib: 400
+ # 25% of limit up to 2G
+ spike_limit_mib: 100
+ check_interval: 5s
+ extensions:
+ zpages: {}
+ memory_ballast:
+ # Memory Ballast size should be max 1/3 to 1/2 of memory.
+ size_mib: 165
+ service:
+ extensions: [zpages, memory_ballast]
+ pipelines:
+ traces:
+ receivers: [otlp, jaeger]
+ processors: [memory_limiter, batch]
+ exporters: [otlp, logging]
+ telemetry:
+ logs:
+ level: "info"
+ ```
+
+
+ 2. Verify the deployment
+ ```shell
+ kubectl get OpenTelemetryCollector -n trading-demo
+ ```
+
+ * the result should look similar to this:
+ ```shell
+ NAME MODE VERSION AGE
+ otelcol-sidecar sidecar 0.47.0 1m
+ ```
+
+## 4. Deploy inspectIT Ocelot
+
+### 1. Deploy inspectIT Ocelot Agent as an `Instrumentation`
+
+Following the [official readme](https://inspectit.github.io/inspectit-ocelot/docs/next/getting-started/installation#using-the-agent-with-kubernetes) from inspectIT Ocelot, we will deploy the inspectIT Ocelot Agent as an `Instrumentation`, that will be automatically injected into the trading demo application by the OpenTelemetry Operator. You can find the file in `./inspectit-ocelot/inspectit-ocelot-instrumentation.yaml`.
+
+1. Deploy the inspectIT Ocelot instrumentation in the `trading-demo` namespace:
+
+ ```shell
+ kubectl apply -f ./inspectit-ocelot/inspectit-ocelot-instrumentation.yaml -n trading-demo
+ ```
+ > **Important**: the instrumentation must be deployed in the same namespace as the target application
+
+2. Verify the deployment
+ ```shell
+ kubectl get Instrumentation -n trading-demo
+ ```
+
+ * the result should look similar to this
+ ```shell
+ NAME AGE ENDPOINT SAMPLER SAMPLER ARG
+ inspectit-ocelot-instrumentation 1m
+ ```
+
+
+### 2. Deploy the inspectIT Ocelot Configuration Server
+
+We will deploy the inspectIT Ocelot Configuration Server following the [official readme](https://github.com/inspectIT/inspectit-ocelot/tree/master/components/inspectit-ocelot-configurationserver/k8s).
+
+You can find the file in `./inspectit-ocelot/inspectit-ocelot-configurationserver.yaml`
+
+1. Deploy the inspectIT Ocelot Configuration Server in the `inspectit-ocelot` namespace:
+ ```shell
+ kubectl apply -f ./inspectit-ocelot/inspectit-ocelot-configurationserver.yaml
+ ```
+
+ * we configure inspectIT Ocelot to trace all methods from the trading demo frontend and backend
+
+2. Verify the deployment
+ ```shell
+ kubectl get all -n inspectit-ocelot
+ ```
+
+ * the result should look similar to this:
+ ```shel
+ NAME READY STATUS RESTARTS AGE
+ pod/inspectit-ocelot-configurationserver-5cbb4c4b6c-45v5h 1/1 Running 1 (3d22h ago) 1m
+
+ NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
+ service/inspectit-ocelot-configurationserver ClusterIP 10.111.128.9 8090/TCP 1m
+
+ NAME READY UP-TO-DATE AVAILABLE AGE
+ deployment.apps/inspectit-ocelot-configurationserver 1/1 1 1 1m
+
+ NAME DESIRED CURRENT READY AGE
+ replicaset.apps/inspectit-ocelot-configurationserver-5cbb4c4b6c 1 1 1 1m
+ ```
+
+3. Use `port-forward` to access the inspectIT Ocelot Configuration Server on [http://localhost:8090](http://localhost:8090)
+
+ > open a new terminal
+
+ ```shell
+ kubectl port-forward -n inspectit-ocelot service/inspectit-ocelot-configurationserver 8090
+ ```
+
+> **Important**: depending on whether you deploy the OpenTelemetry Collector Agent as a sidecar to the trading demo application or whether you export directly to the OpenTelemetry Collector, you need to adjust the `ConfigMap` or the configuration in the Configuration Server UI to use the appropriate endpoint URL for Jaeger.
+
+```yaml
+ inspectit:
+ exporters:
+ tracing:
+ jaeger:
+ enabled: ENABLED
+ # when the OTEL collector agent is injected as a sidecar, we can go with 'localhost'
+ url: http://localhost:14268/api/traces
+ # when the OTEL collector is deployed as an deployment, we need to address it directly
+ url: http://otel-collector.otel.svc.cluster.local:14268/api/traces
+```
+
+## 3. Deploy the Trading Demo Application
+
+In this tutorial, we can deploy the trading demo application either with an OpenTelemetry Collector agent as a [sidecar](#2-deploy-the-opentelemetry-collector-agent-sidecar) or without.
+
+### 1. Deploy with OpenTelemetryCollector Agent as sidecar
+
+The file `./trading-demo/trading-demo-with-otelcol-agent-sidecar.yaml` deploys the trading demo application with the annotation `sidecar.opentelemetry.io/inject: "true"` that tells the OpenTelemetry Operator to inject the OpenTelemetry Collector Agent as a sidecar
+
+```yaml
+spec:
+ ....
+ template:
+ .....
+ metadata:
+ ....
+ annotations:
+ ...
+ sidecar.opentelemetry.io/inject: "true"
+````
+
+1. Deploy the trading demo application
+ ```she
+ kubectl apply -f ./trading-demo/trading-demo-with-otelcol-agent-sidecar.yaml
+ ```
+
+2. Verify the deployment
+
+ ```shell
+ kubectl get all -n trading-demo
+ ```
+
+ * the result should look similar to this:
+ ```shell
+ NAME READY STATUS RESTARTS AGE
+ pod/trading-demo-backend-58fb4dddb5-xv7t5 1/1 Running 0 29s
+ pod/trading-demo-frontend-567797856b-5zj72 1/1 Running 0 29s
+
+ NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
+ service/trading-demo-backend ClusterIP 10.109.11.128 8080/TCP 29s
+ service/trading-demo-frontend ClusterIP 10.109.168.94 8080/TCP 29s
+
+ NAME READY UP-TO-DATE AVAILABLE AGE
+ deployment.apps/trading-demo-backend 1/1 1 1 29s
+ deployment.apps/trading-demo-frontend 1/1 1 1 29s
+
+ NAME DESIRED CURRENT READY AGE
+ replicaset.apps/trading-demo-backend-58fb4dddb5 1 1 1 29s
+ replicaset.apps/trading-demo-frontend-567797856b 1 1 1 29s
+ ```
+
+ * Verify that the OpenTelemetry Collector sidecar has been injected:
+ ```shell
+ kubectl get pods NAME_OF_POD -n trading-demo -o jsonpath='{.spec.containers[*].name}'
+ ```
+
+ - the output should look similar to this:
+
+ ```shell
+ trading-demo-backend otc-container
+ ```
+
+ - the `otc-container` is the OpenTelemetry Collector Agent sidecar
+
+ where `NAME_OF_POD` is the name of pod for the frontend or backend
+
+ * in the above output, the names of the pods are `trading-demo-backend-58fb4dddb5-xv7t5` and `trading-demo-frontend-567797856b-5zj72`
+
+ * you can also retrieve the name of the pod by running
+ ```shell
+ # get the pods for trading-demo-backend
+ kubectl get pods -l app=trading-demo-backend -n trading-demo
+
+ # get the pods for the trading-demo-frontend
+ kubectl get pods -l app=trading-demo-frontend -n trading-demo
+ ```
+
+ * You can also `describe` the deployments to get more insights:
+ ```shell
+ # describe the backend pod
+ kubectl describe pod trading-demo-backend -n trading-demo
+
+ # describe the frontend pod
+ kubectl describe pod trading-demo-frontend -n trading-demo
+ ```
+
+3. Use `port-forward` to access the Trading Demo Frontend on [http://localhost:8080](http://localhost:8080):
+
+ > open a new terminal
+
+ ```shell
+ kubectl port-forward -n trading-demo service/trading-demo-frontend 8080
+ ```
+
+### 2. Alternatively, deploy without sidecar
+
+Alternatively, if you don't want to inject the OpenTelemetry Collector Agent as a sidecar, you can deploy the Trading Demo Application with the file located at `./trading-demo/trading-demo.yaml`.
+
+
+
+
+1. Deploy the trading demo application
+
+ ```she
+ kubectl apply -f ./trading-demo/trading-demo.yaml
+ ```
+
+2. Verify the deployment:
+
+ ```shell
+ kubectl get all -n trading-demo
+ ```
+
+ * the result should look similar to this:
+ ```shell
+ NAME READY STATUS RESTARTS AGE
+ pod/trading-demo-backend-5df5d4db9c-ndhxk 2/2 Running 0 7m18s
+ pod/trading-demo-frontend-7ff6f48846-9jswl 2/2 Running 0 7m18s
+
+ NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
+ service/trading-demo-backend ClusterIP 10.105.71.107 8080/TCP 7m18s
+ service/trading-demo-frontend ClusterIP 10.107.236.99 8080/TCP 7m18s
+
+ NAME READY UP-TO-DATE AVAILABLE AGE
+ deployment.apps/trading-demo-backend 1/1 1 1 7m18s
+ deployment.apps/trading-demo-frontend 1/1 1 1 7m18s
+
+ NAME DESIRED CURRENT READY AGE
+ replicaset.apps/trading-demo-backend-5df5d4db9c 1 1 1 7m18s
+ replicaset.apps/trading-demo-frontend-7ff6f48846 1 1 1 7m18s
+ ```
+
+## 5. Usage
+
+### Links
+
+* Jaeger UI: [http://localhost:16686](http://localhost:16686)
+* inspectIT Ocelot Configuration Server: [http://localhost:8090](http://localhost:8090)
+* Trading demo application frontend: [http://localhost:8080](http://localhost:8080)
+
+> **Important**: you can only access the components on localhost if you activated the port-fowarding as explained in the respective sections.
+
+### Using the demo
+
+See [the official readme](https://github.com/inspectIT/trading-demo-application#using-the-application) of the trading demo application on how to use it:
+
+| Endpoint | Description |
+| ------------------------------------- | ------------------------------------------------------------ |
+| `/info` | Returns some information about the current instance. |
+| `/quote?coin=&amount=` | Requests a quote to buy crypto coins. The coin parameter has to be one of: `BTC`, `ETC`. The amount represents a floating point number. |
+| `/status?quote=` | Returns information about the status of a quote. |
+| `/buy?quote=` | Accepts a quote and executes the related buy order. |
+
+When you have executed some queries on the frontend, visit the Jaeger UI on [http://localhost:16686](http://localhost:16686) and you should see the traces for the
+
+`trading-demo-backend` and `trading-demo-frontend`.
+
+* Verify that traces are received and sent
+
+ 1. Execute some queries, e.g., [http://localhost:8080/quote?coin=BTC&amount=1.25](http://localhost:8080/quote?coin=BTC&amount=1.25)
+
+ 2. Verify the OpenTelemetryCollector receives and exports the traces
+
+ ```shell
+ kubectl logs deploy/otel-collector -n otel
+ ```
+
+ * you should see logs similar to this:
+ ``` shell
+ │ 2022-03-28T12:37:12.902Z info service/collector.go:141 Everything is ready. Begin running and processing data. ││ 2022-03-28T12:37:13.900Z info jaegerexporter@v0.47.0/exporter.go:186 State of the connection with the Jaeger Collector backend {"kind": "exporter", "name": "jaeger", "state": "READY"} ││ 2022-03-28T13:27:01.574Z INFO loggingexporter/logging_exporter.go:40 TracesExporter {"#spans": 1} ││ 2022-03-28T13:27:03.779Z INFO loggingexporter/logging_exporter.go:40 TracesExporter {"#spans": 14} ││ 2022-03-28T13:27:06.585Z INFO loggingexporter/logging_exporter.go:40 TracesExporter {"#spans": 1} ││ 2022-03-28T13:29:56.350Z INFO loggingexporter/logging_exporter.go:40 TracesExporter {"#spans": 1} ││ 2022-03-28T13:29:59.555Z INFO loggingexporter/logging_exporter.go:40 TracesExporter {"#spans": 14} ││ 2022-03-28T13:30:01.359Z INFO loggingexporter/logging_exporter.go:40 TracesExporter {"#spans": 1} ││ 2022-03-28T13:30:06.370Z INFO loggingexporter/logging_exporter.go:40 TracesExporter {"#spans": 1} ││ 2022-03-28T13:30:09.577Z INFO loggingexporter/logging_exporter.go:40 TracesExporter {"#spans": 7} ││ 2022-03-28T13:50:04.617Z INFO loggingexporter/logging_exporter.go:40 TracesExporter {"#spans": 2} ││ 2022-03-28T13:57:49.648Z INFO loggingexporter/logging_exporter.go:40 TracesExporter {"#spans": 14} ││ 2022-03-28T13:57:49.849Z INFO loggingexporter/logging_exporter.go:40 TracesExporter {"#spans": 2} ││ 2022-03-28T14:07:27.332Z INFO loggingexporter/logging_exporter.go:40 TracesExporter {"#spans": 7} ││ 2022-03-28T14:07:28.935Z INFO loggingexporter/logging_exporter.go:40 TracesExporter {"#spans": 1} ││ 2022-03-29T07:22:33.468Z INFO loggingexporter/logging_exporter.go:40 TracesExporter {"#spans": 6}
+ ```
+
+ 3. Visit the [Jaeger UI](http://localhost:16686) and verify that traces from the trading-demo-backend and trading-demo-frontend are received
+
+ * for the request [http://localhost:8080/quote?coin=BTC&amount=1.25](http://localhost:8080/quote?coin=BTC&amount=1.25), the traces for the trading-demo-frontend should look similar to this:
+ 
diff --git a/trading-application-k8s-demo/build.gradle b/trading-application-k8s-demo/build.gradle
new file mode 100644
index 0000000..e69de29
diff --git a/trading-application-k8s-demo/images/2022-03-inspectit-ocelot-k8s-demo-sidecar.png b/trading-application-k8s-demo/images/2022-03-inspectit-ocelot-k8s-demo-sidecar.png
new file mode 100644
index 0000000..6e5104c
Binary files /dev/null and b/trading-application-k8s-demo/images/2022-03-inspectit-ocelot-k8s-demo-sidecar.png differ
diff --git a/trading-application-k8s-demo/images/2022-03-inspectit-ocelot-k8s-demo-sidecar.svg b/trading-application-k8s-demo/images/2022-03-inspectit-ocelot-k8s-demo-sidecar.svg
new file mode 100644
index 0000000..dd7d1a8
--- /dev/null
+++ b/trading-application-k8s-demo/images/2022-03-inspectit-ocelot-k8s-demo-sidecar.svg
@@ -0,0 +1,3 @@
+
+
+
\ No newline at end of file
diff --git a/trading-application-k8s-demo/images/2022-03-inspectit-ocelot-k8s-demo.drawio b/trading-application-k8s-demo/images/2022-03-inspectit-ocelot-k8s-demo.drawio
new file mode 100644
index 0000000..af34471
--- /dev/null
+++ b/trading-application-k8s-demo/images/2022-03-inspectit-ocelot-k8s-demo.drawio
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/trading-application-k8s-demo/images/2022-03-inspectit-ocelot-k8s-demo.png b/trading-application-k8s-demo/images/2022-03-inspectit-ocelot-k8s-demo.png
new file mode 100644
index 0000000..ec3e45c
Binary files /dev/null and b/trading-application-k8s-demo/images/2022-03-inspectit-ocelot-k8s-demo.png differ
diff --git a/trading-application-k8s-demo/images/2022-03-inspectit-ocelot-k8s-demo.svg b/trading-application-k8s-demo/images/2022-03-inspectit-ocelot-k8s-demo.svg
new file mode 100644
index 0000000..6cc6eaf
--- /dev/null
+++ b/trading-application-k8s-demo/images/2022-03-inspectit-ocelot-k8s-demo.svg
@@ -0,0 +1,3 @@
+
+
+
\ No newline at end of file
diff --git a/trading-application-k8s-demo/images/jaeger-traces.png b/trading-application-k8s-demo/images/jaeger-traces.png
new file mode 100644
index 0000000..f37033b
Binary files /dev/null and b/trading-application-k8s-demo/images/jaeger-traces.png differ
diff --git a/trading-application-k8s-demo/inspectit-ocelot/inspectit-ocelot-configurationserver.yaml b/trading-application-k8s-demo/inspectit-ocelot/inspectit-ocelot-configurationserver.yaml
new file mode 100644
index 0000000..7929fe6
--- /dev/null
+++ b/trading-application-k8s-demo/inspectit-ocelot/inspectit-ocelot-configurationserver.yaml
@@ -0,0 +1,109 @@
+kind: Namespace
+apiVersion: v1
+metadata:
+ name: inspectit-ocelot
+ labels:
+ name: inspectit-ocelot
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+ name: inspectit-ocelot-configurationserver-conf
+ namespace: inspectit-ocelot
+ labels:
+ app: inspectit-ocelot-configurationserver
+ component: inspectit-ocelot-configurationserver-conf
+data:
+ inspectit-ocelot-configurationserver-config: |
+ inspectit:
+ exporters:
+ tracing:
+ jaeger:
+ enabled: ENABLED
+ # when the OTEL collector agent is injected as a sidecar, we can go with 'localhost'
+ url: http://localhost:14268/api/traces
+ # when the OTEL collector is deployed as an deployment, we need to address it directly
+ #url: http://otel-collector.otel.svc.cluster.local:14268/api/traces
+ instrumentation:
+ rules:
+ r_method_configuration_trace:
+ include:
+ r_trace_method: true
+ scopes:
+ s_trading_demo_frontend_public: true
+ s_trading_demo_backend_ExchangeController: true
+ r_method_configuration_duration:
+ include:
+ r_method_metric: true
+ scopes: {}
+
+ scopes:
+ s_trading_demo_frontend_public:
+ type:
+ name: rocks.inspectit.demo.frontend
+ matcher-mode: STARTS_WITH
+ methods:
+ - visibility: PUBLIC
+ s_trading_demo_backend_ExchangeController:
+ type:
+ name: rocks.inspectitdemo.backend.ExchangeController
+ matcher-mode: STARTS_WITH
+ methods:
+ - visibility: PUBLIC
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ labels:
+ app: inspectit-ocelot-configurationserver
+ name: inspectit-ocelot-configurationserver
+ namespace: inspectit-ocelot
+spec:
+ replicas: 1
+ selector:
+ matchLabels:
+ app: inspectit-ocelot-configurationserver
+ strategy: {}
+ template:
+ metadata:
+ labels:
+ app: inspectit-ocelot-configurationserver
+ spec:
+ containers:
+ - image: inspectit/inspectit-ocelot-configurationserver
+ name: inspectit-ocelot-configurationserver
+ resources: {}
+ command: ["/bin/sh", "-c"]
+ args: ["mkdir -p /working_directory/files/trading-demo && cp /tmp/trading-demo-config.yaml /working_directory/files/trading-demo/trading-demo-config.yaml && sh /entrypoint.sh"]
+ env:
+ - name: INSPECTIT_CONFIG_SERVER_DEFAULT_USER_PASSWORD
+ value: "demo"
+ volumeMounts:
+ - name: inspectit-ocelot-configurationserver-config-vol
+ mountPath: /tmp/trading-demo-config.yaml
+ subPath: trading-demo-config.yaml
+ volumes:
+ - configMap:
+ name: inspectit-ocelot-configurationserver-conf
+ items:
+ - key: inspectit-ocelot-configurationserver-config
+ path: trading-demo-config.yaml
+ name: inspectit-ocelot-configurationserver-config-vol
+status: {}
+---
+apiVersion: v1
+kind: Service
+metadata:
+ labels:
+ app: inspectit-ocelot-configurationserver
+ name: inspectit-ocelot-configurationserver
+ namespace: inspectit-ocelot
+spec:
+ ports:
+ - port: 8090
+ protocol: TCP
+ targetPort: 8090
+ selector:
+ app: inspectit-ocelot-configurationserver
+status:
+ loadBalancer: {}
\ No newline at end of file
diff --git a/trading-application-k8s-demo/inspectit-ocelot/inspectit-ocelot-instrumentation.yaml b/trading-application-k8s-demo/inspectit-ocelot/inspectit-ocelot-instrumentation.yaml
new file mode 100644
index 0000000..0898388
--- /dev/null
+++ b/trading-application-k8s-demo/inspectit-ocelot/inspectit-ocelot-instrumentation.yaml
@@ -0,0 +1,7 @@
+apiVersion: opentelemetry.io/v1alpha1
+kind: Instrumentation
+metadata:
+ name: inspectit-ocelot-instrumentation
+spec:
+ java:
+ image: inspectit/inspectit-ocelot-agent:1.15.2
\ No newline at end of file
diff --git a/trading-application-k8s-demo/jaeger/jaeger-all-in-one-standalone.yaml b/trading-application-k8s-demo/jaeger/jaeger-all-in-one-standalone.yaml
new file mode 100644
index 0000000..7ddbb2a
--- /dev/null
+++ b/trading-application-k8s-demo/jaeger/jaeger-all-in-one-standalone.yaml
@@ -0,0 +1,55 @@
+apiVersion: v1
+kind: Service
+metadata:
+ name: jaeger
+ namespace: monitoring
+ labels:
+ app: opentelemetry
+ component: jaeger-all-in-one
+spec:
+ clusterIP: None
+ selector:
+ component: jaeger-all-in-one
+ ports:
+ - name: ui
+ protocol: TCP
+ port: 16686
+ targetPort: 16686
+ - name: thrift
+ protocol: TCP
+ port: 14268
+ targetPort: 14268
+ - name: proto
+ protocol: TCP
+ port: 14250
+ targetPort: 14250
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: jaeger
+ namespace: monitoring
+ labels:
+ app: opentelemetry
+ component: jaeger-all-in-one
+spec:
+ selector:
+ matchLabels:
+ app: opentelemetry
+ component: jaeger-all-in-one
+ minReadySeconds: 5
+ progressDeadlineSeconds: 120
+ replicas: 1
+ template:
+ metadata:
+ labels:
+ app: opentelemetry
+ component: jaeger-all-in-one
+ spec:
+ containers:
+ - name: jaeger-all-in-one
+ image: jaegertracing/all-in-one:latest
+ ports:
+ - containerPort: 16686 # ui
+ - containerPort: 14268 # jaeger thrift
+ - containerPort: 14250 # jaeger model.proto
\ No newline at end of file
diff --git a/trading-application-k8s-demo/jaeger/jaeger-all-in-one.yaml b/trading-application-k8s-demo/jaeger/jaeger-all-in-one.yaml
new file mode 100644
index 0000000..df24c43
--- /dev/null
+++ b/trading-application-k8s-demo/jaeger/jaeger-all-in-one.yaml
@@ -0,0 +1,4 @@
+apiVersion: jaegertracing.io/v1
+kind: Jaeger
+metadata:
+ name: jaeger
\ No newline at end of file
diff --git a/trading-application-k8s-demo/otel/otel-collector-contrib.yaml b/trading-application-k8s-demo/otel/otel-collector-contrib.yaml
new file mode 100644
index 0000000..33310c6
--- /dev/null
+++ b/trading-application-k8s-demo/otel/otel-collector-contrib.yaml
@@ -0,0 +1,145 @@
+kind: Namespace
+apiVersion: v1
+metadata:
+ name: otel
+ labels:
+ name: otel
+---
+apiVersion: v1
+kind: Service
+metadata:
+ name: otel-collector
+ namespace: otel
+ labels:
+ app: opentelemetry
+ component: otel-collector
+spec:
+ ports:
+ - name: otlp-grpc # Default endpoint for OpenTelemetry gRPC receiver.
+ port: 4317
+ protocol: TCP
+ targetPort: 4317
+ - name: otlp-http # Default endpoint for OpenTelemetry HTTP receiver.
+ port: 4318
+ protocol: TCP
+ targetPort: 4318
+ - name: metrics # Default endpoint for querying metrics.
+ port: 8888
+ - name: prometheus # Prometheus exporter
+ protocol: TCP
+ port: 8889
+ targetPort: 8889
+ - name: jaeger-ace # Jaeger ACE receiver
+ port: 6831
+ targetPort: 6831
+ protocol: TCP
+ - name: jaeger-inspectit # Jaeger InspectIT Ocelot receiver
+ port: 14268
+ targetPort: 14268
+ protocol: TCP
+ selector:
+ component: otel-collector
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+ name: otel-collector-conf
+ namespace: otel
+ labels:
+ app: opentelemetry
+ component: otel-collector-conf
+data:
+ otel-collector-config: |
+ receivers:
+ otlp:
+ protocols:
+ grpc:
+ http:
+ jaeger:
+ protocols:
+ thrift_compact:
+ thrift_binary:
+ thrift_http:
+ processors:
+ batch:
+ memory_limiter:
+ # 80% of maximum memory up to 2G
+ limit_mib: 1500
+ # 25% of limit up to 2G
+ spike_limit_mib: 512
+ check_interval: 5s
+ extensions:
+ zpages: {}
+ memory_ballast:
+ # Memory Ballast size should be max 1/3 to 1/2 of memory.
+ size_mib: 683
+ exporters:
+ jaeger:
+ # export to Jaeger in the namespace monitoring via gRPC
+ endpoint: "jaeger.monitoring:14250"
+ tls:
+ insecure: true
+ logging:
+ service:
+ extensions: [zpages, memory_ballast]
+ pipelines:
+ traces/1:
+ receivers: [otlp, jaeger]
+ processors: [memory_limiter, batch]
+ exporters: [jaeger, logging]
+ telemetry:
+ logs:
+ level: "info"
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: otel-collector
+ namespace: otel
+ labels:
+ app: opentelemetry
+ component: otel-collector
+spec:
+ selector:
+ matchLabels:
+ app: opentelemetry
+ component: otel-collector
+ minReadySeconds: 5
+ progressDeadlineSeconds: 120
+ replicas: 1
+ template:
+ metadata:
+ labels:
+ app: opentelemetry
+ component: otel-collector
+ spec:
+ containers:
+ - command:
+ - "/otelcol"
+ - "--config=/conf/otel-collector-config.yaml"
+ image: otel/opentelemetry-collector-contrib:0.47.0
+ name: otel-collector
+ resources:
+ limits:
+ cpu: 1
+ memory: 2Gi
+ requests:
+ cpu: 200m
+ memory: 400Mi
+ ports:
+ - containerPort: 55679 # Default endpoint for ZPages.
+ - containerPort: 4317 # Default endpoint for OpenTelemetry receiver.
+ - containerPort: 14250 # Default endpoint for Jaeger gRPC receiver.
+ - containerPort: 14268 # Default endpoint for Jaeger HTTP receiver.
+ - containerPort: 9411 # Default endpoint for Zipkin receiver.
+ - containerPort: 8888 # Default endpoint for querying metrics.
+ volumeMounts:
+ - name: otel-collector-config-vol
+ mountPath: /conf
+ volumes:
+ - configMap:
+ name: otel-collector-conf
+ items:
+ - key: otel-collector-config
+ path: otel-collector-config.yaml
+ name: otel-collector-config-vol
\ No newline at end of file
diff --git a/trading-application-k8s-demo/otel/otel-collector.yaml b/trading-application-k8s-demo/otel/otel-collector.yaml
new file mode 100644
index 0000000..8ae98a2
--- /dev/null
+++ b/trading-application-k8s-demo/otel/otel-collector.yaml
@@ -0,0 +1,145 @@
+kind: Namespace
+apiVersion: v1
+metadata:
+ name: otel
+ labels:
+ name: otel
+---
+apiVersion: v1
+kind: Service
+metadata:
+ name: otel-collector
+ namespace: otel
+ labels:
+ app: opentelemetry
+ component: otel-collector
+spec:
+ ports:
+ - name: otlp-grpc # Default endpoint for OpenTelemetry gRPC receiver.
+ port: 4317
+ protocol: TCP
+ targetPort: 4317
+ - name: otlp-http # Default endpoint for OpenTelemetry HTTP receiver.
+ port: 4318
+ protocol: TCP
+ targetPort: 4318
+ - name: metrics # Default endpoint for querying metrics.
+ port: 8888
+ - name: prometheus # Prometheus exporter
+ protocol: TCP
+ port: 8889
+ targetPort: 8889
+ - name: jaeger-ace # Jaeger ACE receiver
+ port: 6831
+ targetPort: 6831
+ protocol: TCP
+ - name: jaeger-inspectit # Jaeger InspectIT Ocelot receiver
+ port: 14268
+ targetPort: 14268
+ protocol: TCP
+ selector:
+ component: otel-collector
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+ name: otel-collector-conf
+ namespace: otel
+ labels:
+ app: opentelemetry
+ component: otel-collector-conf
+data:
+ otel-collector-config: |
+ receivers:
+ otlp:
+ protocols:
+ grpc:
+ http:
+ jaeger:
+ protocols:
+ thrift_compact:
+ thrift_binary:
+ thrift_http:
+ processors:
+ batch:
+ memory_limiter:
+ # 80% of maximum memory up to 2G
+ limit_mib: 1500
+ # 25% of limit up to 2G
+ spike_limit_mib: 512
+ check_interval: 5s
+ extensions:
+ zpages: {}
+ memory_ballast:
+ # Memory Ballast size should be max 1/3 to 1/2 of memory.
+ size_mib: 683
+ exporters:
+ jaeger:
+ # export to Jaeger in the namespace monitoring via gRPC
+ endpoint: "jaeger.monitoring:14250"
+ tls:
+ insecure: true
+ logging:
+ service:
+ extensions: [zpages, memory_ballast]
+ pipelines:
+ traces/1:
+ receivers: [otlp, jaeger]
+ processors: [memory_limiter, batch]
+ exporters: [jaeger, logging]
+ telemetry:
+ logs:
+ level: "info"
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: otel-collector
+ namespace: otel
+ labels:
+ app: opentelemetry
+ component: otel-collector
+spec:
+ selector:
+ matchLabels:
+ app: opentelemetry
+ component: otel-collector
+ minReadySeconds: 5
+ progressDeadlineSeconds: 120
+ replicas: 1
+ template:
+ metadata:
+ labels:
+ app: opentelemetry
+ component: otel-collector
+ spec:
+ containers:
+ - command:
+ - "/otelcol"
+ - "--config=/conf/otel-collector-config.yaml"
+ image: otel/opentelemetry-collector:0.47.0
+ name: otel-collector
+ resources:
+ limits:
+ cpu: 1
+ memory: 2Gi
+ requests:
+ cpu: 200m
+ memory: 400Mi
+ ports:
+ - containerPort: 55679 # Default endpoint for ZPages.
+ - containerPort: 4317 # Default endpoint for OpenTelemetry receiver.
+ - containerPort: 14250 # Default endpoint for Jaeger gRPC receiver.
+ - containerPort: 14268 # Default endpoint for Jaeger HTTP receiver.
+ - containerPort: 9411 # Default endpoint for Zipkin receiver.
+ - containerPort: 8888 # Default endpoint for querying metrics.
+ volumeMounts:
+ - name: otel-collector-config-vol
+ mountPath: /conf
+ volumes:
+ - configMap:
+ name: otel-collector-conf
+ items:
+ - key: otel-collector-config
+ path: otel-collector-config.yaml
+ name: otel-collector-config-vol
\ No newline at end of file
diff --git a/trading-application-k8s-demo/otel/otel-instrumentation.yaml b/trading-application-k8s-demo/otel/otel-instrumentation.yaml
new file mode 100644
index 0000000..8022b42
--- /dev/null
+++ b/trading-application-k8s-demo/otel/otel-instrumentation.yaml
@@ -0,0 +1,14 @@
+apiVersion: opentelemetry.io/v1alpha1
+kind: Instrumentation
+metadata:
+ name: otel-instrumentation
+spec:
+ exporter:
+ endpoint: http://otel-collector:4317
+ propagators:
+ - tracecontext
+ - baggage
+ - b3
+ sampler:
+ type: parentbased_traceidratio
+ argument: "0.25"
\ No newline at end of file
diff --git a/trading-application-k8s-demo/otel/otelcol-agent-sidecar.yaml b/trading-application-k8s-demo/otel/otelcol-agent-sidecar.yaml
new file mode 100644
index 0000000..1da92f5
--- /dev/null
+++ b/trading-application-k8s-demo/otel/otelcol-agent-sidecar.yaml
@@ -0,0 +1,48 @@
+---
+apiVersion: opentelemetry.io/v1alpha1
+kind: OpenTelemetryCollector
+metadata:
+ name: otelcol-sidecar
+spec:
+ mode: sidecar
+ config: |
+ receivers:
+ otlp:
+ protocols:
+ grpc:
+ http:
+ jaeger:
+ protocols:
+ grpc:
+ thrift_binary:
+ thrift_http:
+ thrift_compact:
+ exporters:
+ otlp:
+ endpoint: "otel-collector.otel.svc.cluster.local:4317"
+ tls:
+ insecure: true
+ logging:
+ processors:
+ batch:
+ memory_limiter:
+ # 80% of maximum memory up to 2G
+ limit_mib: 400
+ # 25% of limit up to 2G
+ spike_limit_mib: 100
+ check_interval: 5s
+ extensions:
+ zpages: {}
+ memory_ballast:
+ # Memory Ballast size should be max 1/3 to 1/2 of memory.
+ size_mib: 165
+ service:
+ extensions: [zpages, memory_ballast]
+ pipelines:
+ traces:
+ receivers: [otlp, jaeger]
+ processors: [memory_limiter, batch]
+ exporters: [otlp, logging]
+ telemetry:
+ logs:
+ level: "info"
\ No newline at end of file
diff --git a/trading-application-k8s-demo/trading-demo/trading-demo-with-otelcol-agent-sidecar.yaml b/trading-application-k8s-demo/trading-demo/trading-demo-with-otelcol-agent-sidecar.yaml
new file mode 100644
index 0000000..b1ec2c4
--- /dev/null
+++ b/trading-application-k8s-demo/trading-demo/trading-demo-with-otelcol-agent-sidecar.yaml
@@ -0,0 +1,146 @@
+kind: Namespace
+apiVersion: v1
+metadata:
+ name: trading-demo
+ labels:
+ name: trading-demo
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ creationTimestamp: null
+ labels:
+ app: trading-demo-backend
+ name: trading-demo-backend
+ namespace: trading-demo
+spec:
+ replicas: 1
+ selector:
+ matchLabels:
+ app: trading-demo-backend
+ strategy: {}
+ template:
+ metadata:
+ creationTimestamp: null
+ labels:
+ app: trading-demo-backend
+ annotations:
+ # inject an instrumentation that has been deployed in the same namespace
+ instrumentation.opentelemetry.io/inject-java: "true"
+ # inject OpenTelemetry Collector as a sidecar
+ sidecar.opentelemetry.io/inject: "true"
+ spec:
+ containers:
+ - image: inspectit/trading-demo
+ name: trading-demo-backend
+ resources: {}
+ env:
+ - name: INSPECTIT_CONFIG_HTTP_URL
+ value: "http://inspectit-ocelot-configurationserver.inspectit-ocelot.svc.cluster.local:8090/api/v1/agent/configuration"
+ - name: INSPECTIT_SERVICE_NAME
+ value: trading-demo-backend
+status: {}
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+ creationTimestamp: null
+ name: ingress
+ namespace: trading-demo
+spec:
+ defaultBackend:
+ service:
+ name: trading-demo-backend
+ port:
+ number: 8080
+status:
+ loadBalancer: {}
+---
+apiVersion: v1
+kind: Service
+metadata:
+ creationTimestamp: null
+ labels:
+ app: trading-demo-backend
+ name: trading-demo-backend
+ namespace: trading-demo
+spec:
+ ports:
+ - port: 8080
+ protocol: TCP
+ targetPort: 8080
+ selector:
+ app: trading-demo-backend
+status:
+ loadBalancer: {}
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ creationTimestamp: null
+ labels:
+ app: trading-demo-frontend
+ name: trading-demo-frontend
+ namespace: trading-demo
+spec:
+ replicas: 1
+ selector:
+ matchLabels:
+ app: trading-demo-frontend
+ strategy: {}
+ template:
+ metadata:
+ creationTimestamp: null
+ labels:
+ app: trading-demo-frontend
+ annotations:
+ # inject an instrumentation that has been deployed in the same namespace
+ instrumentation.opentelemetry.io/inject-java: "true"
+ # inject OpenTelemetry Collector as a sidecar
+ sidecar.opentelemetry.io/inject: "true"
+ spec:
+ containers:
+ - image: inspectit/trading-demo
+ name: trading-demo-frontend
+ resources: {}
+ env:
+ - name: INSPECTIT_CONFIG_HTTP_URL
+ value: "http://inspectit-ocelot-configurationserver.inspectit-ocelot.svc.cluster.local:8090/api/v1/agent/configuration"
+ - name: BACKEND_URL
+ value: http://trading-demo-backend:8080
+ - name: INSPECTIT_SERVICE_NAME
+ value: trading-demo-frontend
+status: {}
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+ creationTimestamp: null
+ name: ingress
+ namespace: trading-demo
+spec:
+ defaultBackend:
+ service:
+ name: trading-demo-frontend
+ port:
+ number: 8080
+status:
+ loadBalancer: {}
+---
+apiVersion: v1
+kind: Service
+metadata:
+ creationTimestamp: null
+ labels:
+ app: trading-demo-frontend
+ name: trading-demo-frontend
+ namespace: trading-demo
+spec:
+ ports:
+ - port: 8080
+ protocol: TCP
+ targetPort: 8080
+ selector:
+ app: trading-demo-frontend
+status:
+ loadBalancer: {}
diff --git a/trading-application-k8s-demo/trading-demo/trading-demo.yaml b/trading-application-k8s-demo/trading-demo/trading-demo.yaml
new file mode 100644
index 0000000..a45370c
--- /dev/null
+++ b/trading-application-k8s-demo/trading-demo/trading-demo.yaml
@@ -0,0 +1,142 @@
+kind: Namespace
+apiVersion: v1
+metadata:
+ name: trading-demo
+ labels:
+ name: trading-demo
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ creationTimestamp: null
+ labels:
+ app: trading-demo-backend
+ name: trading-demo-backend
+ namespace: trading-demo
+spec:
+ replicas: 1
+ selector:
+ matchLabels:
+ app: trading-demo-backend
+ strategy: {}
+ template:
+ metadata:
+ creationTimestamp: null
+ labels:
+ app: trading-demo-backend
+ annotations:
+ # inject an instrumentation that has been deployed in the same namespace
+ instrumentation.opentelemetry.io/inject-java: "true"
+ spec:
+ containers:
+ - image: inspectit/trading-demo
+ name: trading-demo-backend
+ resources: {}
+ env:
+ - name: INSPECTIT_CONFIG_HTTP_URL
+ value: "http://inspectit-ocelot-configurationserver.inspectit-ocelot.svc.cluster.local:8090/api/v1/agent/configuration"
+ - name: INSPECTIT_SERVICE_NAME
+ value: trading-demo-backend
+status: {}
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+ creationTimestamp: null
+ name: ingress
+ namespace: trading-demo
+spec:
+ defaultBackend:
+ service:
+ name: trading-demo-backend
+ port:
+ number: 8080
+status:
+ loadBalancer: {}
+---
+apiVersion: v1
+kind: Service
+metadata:
+ creationTimestamp: null
+ labels:
+ app: trading-demo-backend
+ name: trading-demo-backend
+ namespace: trading-demo
+spec:
+ ports:
+ - port: 8080
+ protocol: TCP
+ targetPort: 8080
+ selector:
+ app: trading-demo-backend
+status:
+ loadBalancer: {}
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ creationTimestamp: null
+ labels:
+ app: trading-demo-frontend
+ name: trading-demo-frontend
+ namespace: trading-demo
+spec:
+ replicas: 1
+ selector:
+ matchLabels:
+ app: trading-demo-frontend
+ strategy: {}
+ template:
+ metadata:
+ creationTimestamp: null
+ labels:
+ app: trading-demo-frontend
+ annotations:
+ # inject an instrumentation that has been deployed in the same namespace
+ instrumentation.opentelemetry.io/inject-java: "true"
+ spec:
+ containers:
+ - image: inspectit/trading-demo
+ name: trading-demo-frontend
+ resources: {}
+ env:
+ - name: INSPECTIT_CONFIG_HTTP_URL
+ value: "http://inspectit-ocelot-configurationserver.inspectit-ocelot.svc.cluster.local:8090/api/v1/agent/configuration"
+ - name: BACKEND_URL
+ value: http://trading-demo-backend:8080
+ - name: INSPECTIT_SERVICE_NAME
+ value: trading-demo-frontend
+status: {}
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+ creationTimestamp: null
+ name: ingress
+ namespace: trading-demo
+spec:
+ defaultBackend:
+ service:
+ name: trading-demo-frontend
+ port:
+ number: 8080
+status:
+ loadBalancer: {}
+---
+apiVersion: v1
+kind: Service
+metadata:
+ creationTimestamp: null
+ labels:
+ app: trading-demo-frontend
+ name: trading-demo-frontend
+ namespace: trading-demo
+spec:
+ ports:
+ - port: 8080
+ protocol: TCP
+ targetPort: 8080
+ selector:
+ app: trading-demo-frontend
+status:
+ loadBalancer: {}
+
+