signalfx.gcp.Integration

using System.Collections.Generic;
using System.IO;
using System.Linq;
using Pulumi;
using SignalFx = Pulumi.SignalFx;

return await Deployment.RunAsync(() => 
{
    var gcpMyteam = new SignalFx.Gcp.Integration("gcpMyteam", new()
    {
        CustomMetricTypeDomains = new[]
        {
            "istio.io",
        },
        Enabled = true,
        ImportGcpMetrics = true,
        PollRate = 300,
        ProjectServiceKeys = new[]
        {
            new SignalFx.Gcp.Inputs.IntegrationProjectServiceKeyArgs
            {
                ProjectId = "gcp_project_id_1",
                ProjectKey = File.ReadAllText("/path/to/gcp_credentials_1.json"),
            },
            new SignalFx.Gcp.Inputs.IntegrationProjectServiceKeyArgs
            {
                ProjectId = "gcp_project_id_2",
                ProjectKey = File.ReadAllText("/path/to/gcp_credentials_2.json"),
            },
        },
        Services = new[]
        {
            "compute",
        },
    });

});

package main

import (
	"os"

	"github.com/pulumi/pulumi-signalfx/sdk/v6/go/signalfx/gcp"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func readFileOrPanic(path string) pulumi.StringPtrInput {
	data, err := os.ReadFile(path)
	if err != nil {
		panic(err.Error())
	}
	return pulumi.String(string(data))
}

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := gcp.NewIntegration(ctx, "gcpMyteam", &gcp.IntegrationArgs{
			CustomMetricTypeDomains: pulumi.StringArray{
				pulumi.String("istio.io"),
			},
			Enabled:          pulumi.Bool(true),
			ImportGcpMetrics: pulumi.Bool(true),
			PollRate:         pulumi.Int(300),
			ProjectServiceKeys: gcp.IntegrationProjectServiceKeyArray{
				&gcp.IntegrationProjectServiceKeyArgs{
					ProjectId:  pulumi.String("gcp_project_id_1"),
					ProjectKey: readFileOrPanic("/path/to/gcp_credentials_1.json"),
				},
				&gcp.IntegrationProjectServiceKeyArgs{
					ProjectId:  pulumi.String("gcp_project_id_2"),
					ProjectKey: readFileOrPanic("/path/to/gcp_credentials_2.json"),
				},
			},
			Services: pulumi.StringArray{
				pulumi.String("compute"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.signalfx.gcp.Integration;
import com.pulumi.signalfx.gcp.IntegrationArgs;
import com.pulumi.signalfx.gcp.inputs.IntegrationProjectServiceKeyArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var gcpMyteam = new Integration("gcpMyteam", IntegrationArgs.builder()        
            .customMetricTypeDomains("istio.io")
            .enabled(true)
            .importGcpMetrics(true)
            .pollRate(300)
            .projectServiceKeys(            
                IntegrationProjectServiceKeyArgs.builder()
                    .projectId("gcp_project_id_1")
                    .projectKey(Files.readString(Paths.get("/path/to/gcp_credentials_1.json")))
                    .build(),
                IntegrationProjectServiceKeyArgs.builder()
                    .projectId("gcp_project_id_2")
                    .projectKey(Files.readString(Paths.get("/path/to/gcp_credentials_2.json")))
                    .build())
            .services("compute")
            .build());

    }
}

import * as pulumi from "@pulumi/pulumi";
import * as fs from "fs";
import * as signalfx from "@pulumi/signalfx";

const gcpMyteam = new signalfx.gcp.Integration("gcpMyteam", {
    customMetricTypeDomains: ["istio.io"],
    enabled: true,
    importGcpMetrics: true,
    pollRate: 300,
    projectServiceKeys: [
        {
            projectId: "gcp_project_id_1",
            projectKey: fs.readFileSync("/path/to/gcp_credentials_1.json"),
        },
        {
            projectId: "gcp_project_id_2",
            projectKey: fs.readFileSync("/path/to/gcp_credentials_2.json"),
        },
    ],
    services: ["compute"],
});

import pulumi
import pulumi_signalfx as signalfx

gcp_myteam = signalfx.gcp.Integration("gcpMyteam",
    custom_metric_type_domains=["istio.io"],
    enabled=True,
    import_gcp_metrics=True,
    poll_rate=300,
    project_service_keys=[
        signalfx.gcp.IntegrationProjectServiceKeyArgs(
            project_id="gcp_project_id_1",
            project_key=(lambda path: open(path).read())("/path/to/gcp_credentials_1.json"),
        ),
        signalfx.gcp.IntegrationProjectServiceKeyArgs(
            project_id="gcp_project_id_2",
            project_key=(lambda path: open(path).read())("/path/to/gcp_credentials_2.json"),
        ),
    ],
    services=["compute"])

resources:
  gcpMyteam:
    type: signalfx:gcp:Integration
    properties:
      customMetricTypeDomains:
        - istio.io
      enabled: true
      importGcpMetrics: true
      pollRate: 300
      projectServiceKeys:
        - projectId: gcp_project_id_1
          projectKey:
            fn::readFile: /path/to/gcp_credentials_1.json
        - projectId: gcp_project_id_2
          projectKey:
            fn::readFile: /path/to/gcp_credentials_2.json
      services:
        - compute