TransferAgentPoolArgs

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

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

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var @default = Gcp.Storage.GetTransferProjectServiceAccount.Invoke(new()
    {
        Project = "my-project-name",
    });
    var pubsubEditorRole = new Gcp.Projects.IAMMember("pubsub_editor_role", new()
    {
        Project = "my-project-name",
        Role = "roles/pubsub.editor",
        Member = @default.Apply(@default => $"serviceAccount:{@default.Apply(getTransferProjectServiceAccountResult => getTransferProjectServiceAccountResult.Email)}"),
    });
    var example = new Gcp.Storage.TransferAgentPool("example", new()
    {
        Name = "agent-pool-example",
        DisplayName = "Source A to destination Z",
        BandwidthLimit = new Gcp.Storage.Inputs.TransferAgentPoolBandwidthLimitArgs
        {
            LimitMbps = "120",
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            pubsubEditorRole,
        },
    });
});

package main
import (
	"fmt"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/projects"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/storage"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_default, err := storage.GetTransferProjectServiceAccount(ctx, &storage.GetTransferProjectServiceAccountArgs{
			Project: pulumi.StringRef("my-project-name"),
		}, nil)
		if err != nil {
			return err
		}
		pubsubEditorRole, err := projects.NewIAMMember(ctx, "pubsub_editor_role", &projects.IAMMemberArgs{
			Project: pulumi.String("my-project-name"),
			Role:    pulumi.String("roles/pubsub.editor"),
			Member:  pulumi.Sprintf("serviceAccount:%v", _default.Email),
		})
		if err != nil {
			return err
		}
		_, err = storage.NewTransferAgentPool(ctx, "example", &storage.TransferAgentPoolArgs{
			Name:        pulumi.String("agent-pool-example"),
			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.GetTransferProjectServiceAccountArgs;
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.getTransferProjectServiceAccount(GetTransferProjectServiceAccountArgs.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()
            .name("agent-pool-example")
            .displayName("Source A to destination Z")
            .bandwidthLimit(TransferAgentPoolBandwidthLimitArgs.builder()
                .limitMbps("120")
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(pubsubEditorRole)
                .build());
    }
}

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

$ pulumi import gcp:storage/transferAgentPool:TransferAgentPool default projects/{{project}}/agentPools/{{name}}

$ pulumi import gcp:storage/transferAgentPool:TransferAgentPool default {{project}}/{{name}}

$ pulumi import gcp:storage/transferAgentPool:TransferAgentPool default {{name}}