# 🦗 Odigos + qryn = zero instrumentation

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1668371603629/YNQ9pgxne.png align="left")

#### Detect and Fix Production Issues Faster with Odigos & qryn

[Odigos](https://github.com/keyval-dev/odigos) is designed to automatically instruments get distributed traces, metrics and logs for any Kubernetes application in minutes, without any code changes.

**Odigos** detects the programming language of your applications and applies automatic instrumentation using well-known, battle-tested open source observability technologies such as **OpenTelemetry** and **eBPF**.

## Tutorial

In this tutorial we are going to use **Odigos** for getting automatic observability of a microservices application written in *Go, Java, Python, .NET and Node*.

Odigos v0.1.36+ natively supports **qryn** as destination for *traces, logs and metrics*.

📚 This guide is adapted from the [odigos documentation examples](https://odigos.io/docs/getting-started/#choosing-where-to-send-the-data)

### Prerequisites

To follow the guide, you need the following:

* A **Kubernetes** cluster.
    
* **Helm CLI** for installing helm charts.
    
* A **qryn** or **qryn.cloud** deployment.
    

### Creating the Kubernetes cluster

Create a new local Kubernetes cluster, by running the following command:

```plaintext
kind create cluster
```

### Deploying the target application

For this tutorial, we are going to install a fork of [microservices-demo](https://github.com/keyval-dev/microservices-demo). We use a modified version without any instrumentation code to demonstrate how Odigos automatically collects observability data from the application.

Deploy the demo application using the following command:

```plaintext
kubectl apply -f https://raw.githubusercontent.com/keyval-dev/microservices-demo/master/release/kubernetes-manifests.yaml
```

Before proceeding, make sure that *all the application pods are running.*

## Installing Odigos

The easiest way to install **Odigos** is to use the official helm chart:

```plaintext
helm repo add odigos https://keyval-dev.github.io/odigos-charts/
helm install my-odigos odigos/odigos --namespace odigos-system --create-namespace
```

After all the pods in the `odigos-system` namespace are running, open the Odigos UI by running the following command and navigate to \[http://localhost:3000\]

```plaintext
kubectl port-forward svc/odigos-ui 3000:3000 -n odigos-system
```

### Choosing where to send the data

You should now see the following page:

![image.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1668370960702/n3KKkeh-_.png align="left")

After **Odigos** detected all the applications in the cluster, choose the `opt out` option for application instrumentation. `opt in` mode is recommended when you want to have greater control over which applications are instrumented.

On the next page, select `qryn` as the destination for the data:

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1670182473440/8fBxmI7Yi.png align="left")

Fill in the following information using your relevant **qryn** details:

* **Tempo URL**: `https://qryn.host/tempo/api/push`
    
* **Prometheus URL**: `https://qryn.host/api/prom/remote/write`
    
* **Loki URL**: `https://qryn.host/loki/api/v1/push`
    

### Generating data

That’s it! Odigos will automatically do the following:

* Instrument all the applications in the cluster:
    
* Runtime languages will be instrumented using **OpenTelemetry**.
    
* Compiled languages will be instrumented using **eBPF**.
    
* Deploy and configure a collector to send the data to **qryn**.
    

Now all that is left is to generate some traffic in the application.

Execute the following command to port forward into the application UI:

```plaintext
kubectl port-forward svc/frontend 1234:80 -n default
```

Navigate to \[http://localhost:1234\] and perform fake some purchases.

### Exploring the collected data

Within minutes, you should see distributed traces appear in **qryn**. You now have all the data needed to understand how your application is behaving, without having to do any additional work. Using this configuration any new application deployed to this Kubernetes cluster will automatically be instrumented and sent to **qryn**.

![image.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1668430911556/xNjwxVD-R.png align="left")

#### Cleanup

Delete the Kubernetes cluster by running the following command:

```plaintext
kind delete cluster
```

## Conclusion

**Odigos** is pretty amazing at generating distributed traces, metrics and logs for any K8s application in minutes, and **qryn** supports it as transparently as it should acting as a polyglot backend for all datatypes, without wasting your time with complexity.

Kudos to team [keyval](https://keyval.dev) for this fantastic project. Check out [Odigos Cloud,](https://odigos.io/) too!

*Have fun instrumenting your real Applications, and please share your comments!*

### 🌥 qryn cloud

Try this example and many more from the comfort of your screen using [**qryn cloud**](https://qryn.cloud)

[![](https://github.com/metrico/qryn-docs/assets/1423657/a5164f98-d3ed-4638-afe5-c87d252c74af align="left")](https://qryn.dev)