dynatrace.GcpPrincipal

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

const config = new pulumi.Config();
// The Google Cloud Platform project ID
const gcpProjectId = config.require("gcpProjectId");
// Create a Service Account in GCP
const impersonableServiceAccount = new gcp.serviceaccount.Account("impersonable_service_account", {
    accountId: "test-service-account",
    displayName: "Test Service Account",
});
// Provision the DT GCP Principal. This resource takes no input; it triggers creation of the
// Dynatrace-managed principal (a singleton) and exposes it via the `principal` attribute.
const principal = new dynatrace.GcpPrincipal("principal", {});
// Grant DT GCP Principal access to the service account
const wifBinding = new gcp.serviceaccount.IAMMember("wif_binding", {
    serviceAccountId: impersonableServiceAccount.name,
    member: pulumi.interpolate`serviceAccount:${principal.principal}`,
    role: "roles/iam.serviceAccountTokenCreator",
});
// Create GCP connection
const myGcpConnection = new dynatrace.GcpConnection("my_gcp_connection", {
    name: "My Gcp Connection",
    type: "serviceAccountImpersonation",
    serviceAccountImpersonation: {
        serviceAccountId: impersonableServiceAccount.email,
        consumers: ["SVC:com.dynatrace.da"],
    },
}, {
    dependsOn: [wifBinding],
});

import pulumi
import pulumi_gcp as gcp
import pulumiverse_dynatrace as dynatrace

config = pulumi.Config()
# The Google Cloud Platform project ID
gcp_project_id = config.require("gcpProjectId")
# Create a Service Account in GCP
impersonable_service_account = gcp.serviceaccount.Account("impersonable_service_account",
    account_id="test-service-account",
    display_name="Test Service Account")
# Provision the DT GCP Principal. This resource takes no input; it triggers creation of the
# Dynatrace-managed principal (a singleton) and exposes it via the `principal` attribute.
principal = dynatrace.GcpPrincipal("principal")
# Grant DT GCP Principal access to the service account
wif_binding = gcp.serviceaccount.IAMMember("wif_binding",
    service_account_id=impersonable_service_account.name,
    member=principal.principal.apply(lambda principal: f"serviceAccount:{principal}"),
    role="roles/iam.serviceAccountTokenCreator")
# Create GCP connection
my_gcp_connection = dynatrace.GcpConnection("my_gcp_connection",
    name="My Gcp Connection",
    type="serviceAccountImpersonation",
    service_account_impersonation={
        "service_account_id": impersonable_service_account.email,
        "consumers": ["SVC:com.dynatrace.da"],
    },
    opts = pulumi.ResourceOptions(depends_on=[wif_binding]))

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/serviceaccount"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
	"github.com/pulumiverse/pulumi-dynatrace/sdk/go/dynatrace"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		// The Google Cloud Platform project ID
		gcpProjectId := cfg.Require("gcpProjectId")
		// Create a Service Account in GCP
		impersonableServiceAccount, err := serviceaccount.NewAccount(ctx, "impersonable_service_account", &serviceaccount.AccountArgs{
			AccountId:   pulumi.String("test-service-account"),
			DisplayName: pulumi.String("Test Service Account"),
		})
		if err != nil {
			return err
		}
		// Provision the DT GCP Principal. This resource takes no input; it triggers creation of the
		// Dynatrace-managed principal (a singleton) and exposes it via the `principal` attribute.
		principal, err := dynatrace.NewGcpPrincipal(ctx, "principal", nil)
		if err != nil {
			return err
		}
		// Grant DT GCP Principal access to the service account
		wifBinding, err := serviceaccount.NewIAMMember(ctx, "wif_binding", &serviceaccount.IAMMemberArgs{
			ServiceAccountId: impersonableServiceAccount.Name,
			Member: principal.Principal.ApplyT(func(principal string) (string, error) {
				return fmt.Sprintf("serviceAccount:%v", principal), nil
			}).(pulumi.StringOutput),
			Role: pulumi.String("roles/iam.serviceAccountTokenCreator"),
		})
		if err != nil {
			return err
		}
		// Create GCP connection
		_, err = dynatrace.NewGcpConnection(ctx, "my_gcp_connection", &dynatrace.GcpConnectionArgs{
			Name: pulumi.String("My Gcp Connection"),
			Type: pulumi.String("serviceAccountImpersonation"),
			ServiceAccountImpersonation: &dynatrace.GcpConnectionServiceAccountImpersonationArgs{
				ServiceAccountId: impersonableServiceAccount.Email,
				Consumers: pulumi.StringArray{
					pulumi.String("SVC:com.dynatrace.da"),
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			wifBinding,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Dynatrace = Pulumiverse.Dynatrace;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    // The Google Cloud Platform project ID
    var gcpProjectId = config.Require("gcpProjectId");
    // Create a Service Account in GCP
    var impersonableServiceAccount = new Gcp.ServiceAccount.Account("impersonable_service_account", new()
    {
        AccountId = "test-service-account",
        DisplayName = "Test Service Account",
    });

    // Provision the DT GCP Principal. This resource takes no input; it triggers creation of the
    // Dynatrace-managed principal (a singleton) and exposes it via the `principal` attribute.
    var principal = new Dynatrace.GcpPrincipal("principal");

    // Grant DT GCP Principal access to the service account
    var wifBinding = new Gcp.ServiceAccount.IAMMember("wif_binding", new()
    {
        ServiceAccountId = impersonableServiceAccount.Name,
        Member = principal.Principal.Apply(principal => $"serviceAccount:{principal}"),
        Role = "roles/iam.serviceAccountTokenCreator",
    });

    // Create GCP connection
    var myGcpConnection = new Dynatrace.GcpConnection("my_gcp_connection", new()
    {
        Name = "My Gcp Connection",
        Type = "serviceAccountImpersonation",
        ServiceAccountImpersonation = new Dynatrace.Inputs.GcpConnectionServiceAccountImpersonationArgs
        {
            ServiceAccountId = impersonableServiceAccount.Email,
            Consumers = new[]
            {
                "SVC:com.dynatrace.da",
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            wifBinding,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.serviceaccount.Account;
import com.pulumi.gcp.serviceaccount.AccountArgs;
import com.pulumi.dynatrace.GcpPrincipal;
import com.pulumi.gcp.serviceaccount.IAMMember;
import com.pulumi.gcp.serviceaccount.IAMMemberArgs;
import com.pulumi.dynatrace.GcpConnection;
import com.pulumi.dynatrace.GcpConnectionArgs;
import com.pulumi.dynatrace.inputs.GcpConnectionServiceAccountImpersonationArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        final var config = ctx.config();
        final var gcpProjectId = config.require("gcpProjectId");
        // Create a Service Account in GCP
        var impersonableServiceAccount = new Account("impersonableServiceAccount", AccountArgs.builder()
            .accountId("test-service-account")
            .displayName("Test Service Account")
            .build());

        // Provision the DT GCP Principal. This resource takes no input; it triggers creation of the
        // Dynatrace-managed principal (a singleton) and exposes it via the `principal` attribute.
        var principal = new GcpPrincipal("principal");

        // Grant DT GCP Principal access to the service account
        var wifBinding = new IAMMember("wifBinding", IAMMemberArgs.builder()
            .serviceAccountId(impersonableServiceAccount.name())
            .member(principal.principal().applyValue(_principal -> String.format("serviceAccount:%s", _principal)))
            .role("roles/iam.serviceAccountTokenCreator")
            .build());

        // Create GCP connection
        var myGcpConnection = new GcpConnection("myGcpConnection", GcpConnectionArgs.builder()
            .name("My Gcp Connection")
            .type("serviceAccountImpersonation")
            .serviceAccountImpersonation(GcpConnectionServiceAccountImpersonationArgs.builder()
                .serviceAccountId(impersonableServiceAccount.email())
                .consumers("SVC:com.dynatrace.da")
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(wifBinding)
                .build());

    }
}

configuration:
  gcpProjectId:
    type: string
resources:
  # Create a Service Account in GCP
  impersonableServiceAccount:
    type: gcp:serviceaccount:Account
    name: impersonable_service_account
    properties:
      accountId: test-service-account
      displayName: Test Service Account
  # Provision the DT GCP Principal. This resource takes no input; it triggers creation of the
  # Dynatrace-managed principal (a singleton) and exposes it via the `principal` attribute.
  principal:
    type: dynatrace:GcpPrincipal
  # Grant DT GCP Principal access to the service account
  wifBinding:
    type: gcp:serviceaccount:IAMMember
    name: wif_binding
    properties:
      serviceAccountId: ${impersonableServiceAccount.name}
      member: serviceAccount:${principal.principal}
      role: roles/iam.serviceAccountTokenCreator
  # Create GCP connection
  myGcpConnection:
    type: dynatrace:GcpConnection
    name: my_gcp_connection
    properties:
      name: My Gcp Connection
      type: serviceAccountImpersonation
      serviceAccountImpersonation:
        serviceAccountId: ${impersonableServiceAccount.email}
        consumers:
          - SVC:com.dynatrace.da
    options:
      dependsOn:
        - ${wifBinding}

pulumi {
  required_providers {
    dynatrace = {
      source = "pulumi/dynatrace"
    }
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

# Create a Service Account in GCP
resource "gcp_serviceaccount_account" "impersonable_service_account" {
  account_id   = "test-service-account"
  display_name = "Test Service Account"
}
# Provision the DT GCP Principal. This resource takes no input; it triggers creation of the
# Dynatrace-managed principal (a singleton) and exposes it via the `principal` attribute.
resource "dynatrace_gcpprincipal" "principal" {
}
# Grant DT GCP Principal access to the service account
resource "gcp_serviceaccount_iammember" "wif_binding" {
  service_account_id = gcp_serviceaccount_account.impersonable_service_account.name
  member             ="serviceAccount:${dynatrace_gcpprincipal.principal.principal}"
  role               = "roles/iam.serviceAccountTokenCreator"
}
# Create GCP connection
resource "dynatrace_gcpconnection" "my_gcp_connection" {
  depends_on = [gcp_serviceaccount_iammember.wif_binding]
  name       = "My Gcp Connection"
  type       = "serviceAccountImpersonation"
  service_account_impersonation = {
    service_account_id = gcp_serviceaccount_account.impersonable_service_account.email
    consumers          = ["SVC:com.dynatrace.da"]
  }
}
variable "gcpProjectId" {
  type        = string
  description = "The Google Cloud Platform project ID"
}

var gcpPrincipalResource = new Dynatrace.GcpPrincipal("gcpPrincipalResource");

example, err := dynatrace.NewGcpPrincipal(ctx, "gcpPrincipalResource", nil)

resource "dynatrace_gcpprincipal" "gcpPrincipalResource" {
}

var gcpPrincipalResource = new GcpPrincipal("gcpPrincipalResource");

gcp_principal_resource = dynatrace.GcpPrincipal("gcpPrincipalResource")

const gcpPrincipalResource = new dynatrace.GcpPrincipal("gcpPrincipalResource", {});

type: dynatrace:GcpPrincipal
properties: {}