gcp.storage.TransferAgentPool

using System.Collections.Generic;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() => 
{
    var @default = Gcp.Storage.GetTransferProjectServieAccount.Invoke(new()
    {
        Project = "my-project-name",
    });

    var pubsubEditorRole = new Gcp.Projects.IAMMember("pubsubEditorRole", new()
    {
        Project = "my-project-name",
        Role = "roles/pubsub.editor",
        Member = @default.Apply(@default => $"serviceAccount:{@default.Apply(getTransferProjectServieAccountResult => getTransferProjectServieAccountResult.Email)}"),
    });

    var example = new Gcp.Storage.TransferAgentPool("example", new()
    {
        DisplayName = "Source A to destination Z",
        BandwidthLimit = new Gcp.Storage.Inputs.TransferAgentPoolBandwidthLimitArgs
        {
            LimitMbps = "120",
        },
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            pubsubEditorRole,
        },
    });

});

package main

import (
	"fmt"

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_default, err := storage.GetTransferProjectServieAccount(ctx, &storage.GetTransferProjectServieAccountArgs{
			Project: pulumi.StringRef("my-project-name"),
		}, nil)
		if err != nil {
			return err
		}
		pubsubEditorRole, err := projects.NewIAMMember(ctx, "pubsubEditorRole", &projects.IAMMemberArgs{
			Project: pulumi.String("my-project-name"),
			Role:    pulumi.String("roles/pubsub.editor"),
			Member:  pulumi.String(fmt.Sprintf("serviceAccount:%v", _default.Email)),
		})
		if err != nil {
			return err
		}
		_, err = storage.NewTransferAgentPool(ctx, "example", &storage.TransferAgentPoolArgs{
			DisplayName: pulumi.String("Source A to destination Z"),
			BandwidthLimit: &storage.TransferAgentPoolBandwidthLimitArgs{
				LimitMbps: pulumi.String("120"),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			pubsubEditorRole,
		}))
		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.gcp.storage.StorageFunctions;
import com.pulumi.gcp.storage.inputs.GetTransferProjectServieAccountArgs;
import com.pulumi.gcp.projects.IAMMember;
import com.pulumi.gcp.projects.IAMMemberArgs;
import com.pulumi.gcp.storage.TransferAgentPool;
import com.pulumi.gcp.storage.TransferAgentPoolArgs;
import com.pulumi.gcp.storage.inputs.TransferAgentPoolBandwidthLimitArgs;
import com.pulumi.resources.CustomResourceOptions;
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) {
        final var default = StorageFunctions.getTransferProjectServieAccount(GetTransferProjectServieAccountArgs.builder()
            .project("my-project-name")
            .build());

        var pubsubEditorRole = new IAMMember("pubsubEditorRole", IAMMemberArgs.builder()        
            .project("my-project-name")
            .role("roles/pubsub.editor")
            .member(String.format("serviceAccount:%s", default_.email()))
            .build());

        var example = new TransferAgentPool("example", TransferAgentPoolArgs.builder()        
            .displayName("Source A to destination Z")
            .bandwidthLimit(TransferAgentPoolBandwidthLimitArgs.builder()
                .limitMbps("120")
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(pubsubEditorRole)
                .build());

    }
}

import pulumi
import pulumi_gcp as gcp

default = gcp.storage.get_transfer_project_servie_account(project="my-project-name")
pubsub_editor_role = gcp.projects.IAMMember("pubsubEditorRole",
    project="my-project-name",
    role="roles/pubsub.editor",
    member=f"serviceAccount:{default.email}")
example = gcp.storage.TransferAgentPool("example",
    display_name="Source A to destination Z",
    bandwidth_limit=gcp.storage.TransferAgentPoolBandwidthLimitArgs(
        limit_mbps="120",
    ),
    opts=pulumi.ResourceOptions(depends_on=[pubsub_editor_role]))

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

const default = gcp.storage.getTransferProjectServieAccount({
    project: "my-project-name",
});
const pubsubEditorRole = new gcp.projects.IAMMember("pubsubEditorRole", {
    project: "my-project-name",
    role: "roles/pubsub.editor",
    member: _default.then(_default => `serviceAccount:${_default.email}`),
});
const example = new gcp.storage.TransferAgentPool("example", {
    displayName: "Source A to destination Z",
    bandwidthLimit: {
        limitMbps: "120",
    },
}, {
    dependsOn: [pubsubEditorRole],
});

resources:
  pubsubEditorRole:
    type: gcp:projects:IAMMember
    properties:
      project: my-project-name
      role: roles/pubsub.editor
      member: serviceAccount:${default.email}
  example:
    type: gcp:storage:TransferAgentPool
    properties:
      displayName: Source A to destination Z
      bandwidthLimit:
        limitMbps: '120'
    options:
      dependson:
        - ${pubsubEditorRole}
variables:
  default:
    fn::invoke:
      Function: gcp:storage:getTransferProjectServieAccount
      Arguments:
        project: my-project-name