Using kubernetes opentelemetry.io with kubernetes.crossplane.io

Question

Pulumi · Accepted Answer

Opentelemetry and Crossplane are both used for different purposes in the context of Kubernetes. Opentelemetry is a set of APIs, SDKs, tooling, and integrations that are designed to create and manage telemetry data (metrics, logs, and traces) for cloud-native software. On the other hand, Crossplane is an open-source Kubernetes add-on that enables you to manage your infrastructure in the same way you manage your applications: through Kubernetes.

To use Opentelemetry together with Kubernetes managed through Crossplane, you would want to provision your Kubernetes cluster using Crossplane and then deploy Opentelemetry operators or agents on this cluster to collect telemetry data.

Below is an explanation and a Pulumi program written in TypeScript to provision a Kubernetes cluster using Crossplane and set up Opentelemetry. The example will cover the setup of a basic Kubernetes cluster using the Crossplane provider and then introduce how you might deploy an Opentelemetry collector to the cluster.

### Provisioning the Kubernetes Cluster with Crossplane

First, you need to set up a Crossplane provider that allows you to manage your Kubernetes cluster. We will use the Crossplane Kubernetes provider to do this in the program. You would typically install Crossplane into your Kubernetes cluster, and then configure the Kubernetes provider to manage resources in the target cluster.

### Setting Up Opentelemetry on the Cluster

Once the Kubernetes cluster is provisioned, we will set up Opentelemetry by applying the necessary Kubernetes manifests to this cluster. These manifests might typically include a CustomResourceDefinition (CRD) for the Opentelemetry operator, as well as instances of that CRD to configure Opentelemetry collectors or agents.

Please note, to fully execute the following example, you should have Crossplane installed on your target Kubernetes cluster and cloud provider credentials configured in your environment. The provided setup assumes you are targeting an existing cluster with Crossplane and does not include the manifests for deploying Opentelemetry components, as these are highly customizable and should be defined according to your telemetry needs.

Let's write the program.

```typescript
import * as k8s from "@pulumi/kubernetes";
import * as crossplane from "@pulumi/crossplane";

// Initialize a Kubernetes provider using Crossplane.
const kubeProvider = new k8s.Provider('kubeProvider', {
    kubeconfig: '<Your-Crossplane-Kubeconfig>',
});

// Assuming you have the necessary CRDs already installed on your cluster,
// you would setup your Opentelemetry components something like this:

// Create a Kubernetes namespace where the Opentelemetry components will reside.
const otelNamespace = new k8s.core.v1.Namespace('otel-namespace', {
   metadata: {
       name: 'opentelemetry'
   } 
}, { provider: kubeProvider });

// Deploying an Opentelemetry Collector as an example
const otelCollector = new k8s.apps.v1.Deployment('otel-collector', {
    metadata: {
        namespace: otelNamespace.metadata.name,
        name: 'opentelemetry-collector',
    },
    spec: {
        selector: { matchLabels: { app: 'opentelemetry-collector' } },
        replicas: 1,
        template: {
            metadata: { labels: { app: 'opentelemetry-collector' } },
            spec: {
                containers: [{
                    name: 'otel-collector',
                    image: 'otel/opentelemetry-collector', // Use the correct image
                    ports: [{ containerPort: 4317 }], // Default OTLP gRPC receiver port
                    // Depending on your configuration, you might need to provide
                    // additional command args, environment variables, config maps, etc.
                }],
            },
        },
    },
}, { provider: kubeProvider });

// Export the name of the namespace
export const namespaceName = otelNamespace.metadata.name;
```

In this example, we created a namespace for Opentelemetry components and then a deployment for the Opentelemetry collector. Depending on your specific Opentelemetry configuration, you would need to adjust the deployment to include the necessary config maps for your collectors, sidecars for your applications if needed, and any other supporting resources.

This is only the foundational start. You'd also want to configure storage, access permissions, and other parts of the Kubernetes stack to support Observability with Opentelemetry. To learn more about the manifest specifics, you should refer to the [Opentelemetry documentation](https://opentelemetry.io/docs/collector/).

Please remember that this program assumes that all the necessary providers are already installed and configured on your Pulumi CLI and that the appropriate Crossplane configurations are present in your Kubernetes cluster. The specific image for the Opentelemetry collector and any additional configuration details should be modified to suit your requirements.