What is the procedure for integrating Dyntrace with Google Cloud Run in TypeScript

Question

Pulumi · Accepted Answer

Integrating Dynatrace with Google Cloud Run allows you to monitor the performance of your Cloud Run services by collecting metrics, traces, and logs. The integration can provide insights into the health of your services and help you debug issues more efficiently.

Here’s a procedure to integrate Dynatrace with Google Cloud Run using Pulumi in TypeScript. We'll achieve this by using the appropriate Pulumi resources to set up a Google Cloud Run service and then configure it to send data to Dynatrace.

Prerequisites:

Before proceeding, make sure you have:

A Dynatrace environment with an appropriate API token.
Pulumi CLI installed and configured with access to your Google Cloud Platform account.
gcloud CLI installed and authenticated to your Google Cloud account with the necessary permissions.

Step 1: Create a new Pulumi project

Create a new directory for your Pulumi project and initialize a new Pulumi program:

mkdir pulumi-dynatrace-gcr-integration
cd pulumi-dynatrace-gcr-integration
pulumi new typescript

Step 2: Install necessary packages

Install the @pulumi/gcp and @pulumi/dynatrace packages using npm or yarn:

npm install @pulumi/gcp @pulumi/dynatrace

Step 3: Write the Pulumi program

Write the TypeScript program that creates a Google Cloud Run service and sets environment variables to integrate with Dynatrace. You will need to add the Dynatrace environment variables to the container specification so that it can communicate with the Dynatrace agents.

Now, for the actual Pulumi program. Below is a TypeScript program that sets up a simple Cloud Run service and configures Dynatrace integration:

import * as gcp from "@pulumi/gcp";
import * as pulumi from "@pulumi/pulumi";

// Set your Dynatrace variables
const dynatraceApiToken = "<YOUR_DYNATRACE_API_TOKEN>";
const dynatraceEnvironmentId = "<YOUR_DYNATRACE_ENVIRONMENT_ID>";

// Create a Google Cloud Run service
const cloudRunService = new gcp.cloudrun.Service("my-cloud-run-service", {
    location: "us-central1", // Change this to your preferred location
    template: {
        spec: {
            containers: [{
                image: "gcr.io/cloudrun/hello", // Replace with your container image
                envs: [
                    // Dynatrace environment variables
                    {
                        name: "DT_API_TOKEN",
                        value: dynatraceApiToken, // Your Dynatrace API token for authentication
                    },
                    {
                        name: "DT_ENVIRONMENT_ID",
                        value: dynatraceEnvironmentId, // Your Dynatrace Environment ID
                    },
                    // Any other necessary environment variables
                ],
            }],
        },
    },
});

// Export the service URL
export const url = cloudRunService.statuses.apply(s => s[0].url);

Replace <YOUR_DYNATRACE_API_TOKEN> and <YOUR_DYNATRACE_ENVIRONMENT_ID> with your actual Dynatrace API token and environment ID respectively.

Step 4: Deploy your project

Run the following command to deploy your service:

pulumi up

The DT_API_TOKEN and DT_ENVIRONMENT_ID environment variables are necessary for your Cloud Run service to authenticate with the Dynatrace APIs and send the appropriate telemetry data.

After deploying, Pulumi will provide you with the URL of the deployed Cloud Run service as an output. You can access this URL to interact with your service, which will be monitored by Dynatrace thanks to the environment variables that were set up in the container specification.

This integration code assumes you're managing configurations like API tokens directly in the code for simplicity's sake, but in a production environment, you'd want to manage secrets more securely, possibly using a manager like Google Secret Manager, Pulumi secrets, or environment variables outside of source control.

Step 5: Verify the integration

After the service is deployed and running, log in to your Dynatrace console to ensure that the metrics from your Cloud Run service are appearing as expected.

Further Steps

You can further customize your Cloud Run deployment and Dynatrace integration with additional Pulumi resources or configuration options. Consult the Pulumi Google Cloud Run documentation and the Dynatrace API documentation for more details.

Using IaC tools like Pulumi provides a structured and repeatable way of deploying and managing infrastructure, which is essential for maintaining consistent performance monitoring with Dynatrace across your services and environments.