pulumi-gcp-kotlin/com.pulumi.gcp.developerconnect.kotlin/AccountConnector

AccountConnector

class AccountConnector : KotlinCustomResource

Description

Example Usage

Developer Connect Account Connector Github

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const my_account_connector = new gcp.developerconnect.AccountConnector("my-account-connector", {
    location: "us-central1",
    accountConnectorId: "tf-test-ac",
    providerOauthConfig: {
        systemProviderId: "GITHUB",
        scopes: ["repo"],
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
my_account_connector = gcp.developerconnect.AccountConnector("my-account-connector",
    location="us-central1",
    account_connector_id="tf-test-ac",
    provider_oauth_config={
        "system_provider_id": "GITHUB",
        "scopes": ["repo"],
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var my_account_connector = new Gcp.DeveloperConnect.AccountConnector("my-account-connector", new()
    {
        Location = "us-central1",
        AccountConnectorId = "tf-test-ac",
        ProviderOauthConfig = new Gcp.DeveloperConnect.Inputs.AccountConnectorProviderOauthConfigArgs
        {
            SystemProviderId = "GITHUB",
            Scopes = new[]
            {
                "repo",
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/developerconnect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := developerconnect.NewAccountConnector(ctx, "my-account-connector", &developerconnect.AccountConnectorArgs{
			Location:           pulumi.String("us-central1"),
			AccountConnectorId: pulumi.String("tf-test-ac"),
			ProviderOauthConfig: &developerconnect.AccountConnectorProviderOauthConfigArgs{
				SystemProviderId: pulumi.String("GITHUB"),
				Scopes: pulumi.StringArray{
					pulumi.String("repo"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.developerconnect.AccountConnector;
import com.pulumi.gcp.developerconnect.AccountConnectorArgs;
import com.pulumi.gcp.developerconnect.inputs.AccountConnectorProviderOauthConfigArgs;
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 my_account_connector = new AccountConnector("my-account-connector", AccountConnectorArgs.builder()
            .location("us-central1")
            .accountConnectorId("tf-test-ac")
            .providerOauthConfig(AccountConnectorProviderOauthConfigArgs.builder()
                .systemProviderId("GITHUB")
                .scopes("repo")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  my-account-connector:
    type: gcp:developerconnect:AccountConnector
    properties:
      location: us-central1
      accountConnectorId: tf-test-ac
      providerOauthConfig:
        systemProviderId: GITHUB
        scopes:
          - repo
Content copied to clipboard

Developer Connect Account Connector Gitlab

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const my_account_connector = new gcp.developerconnect.AccountConnector("my-account-connector", {
    location: "us-central1",
    accountConnectorId: "tf-test-ac",
    providerOauthConfig: {
        systemProviderId: "GITLAB",
        scopes: ["api"],
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
my_account_connector = gcp.developerconnect.AccountConnector("my-account-connector",
    location="us-central1",
    account_connector_id="tf-test-ac",
    provider_oauth_config={
        "system_provider_id": "GITLAB",
        "scopes": ["api"],
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var my_account_connector = new Gcp.DeveloperConnect.AccountConnector("my-account-connector", new()
    {
        Location = "us-central1",
        AccountConnectorId = "tf-test-ac",
        ProviderOauthConfig = new Gcp.DeveloperConnect.Inputs.AccountConnectorProviderOauthConfigArgs
        {
            SystemProviderId = "GITLAB",
            Scopes = new[]
            {
                "api",
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/developerconnect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := developerconnect.NewAccountConnector(ctx, "my-account-connector", &developerconnect.AccountConnectorArgs{
			Location:           pulumi.String("us-central1"),
			AccountConnectorId: pulumi.String("tf-test-ac"),
			ProviderOauthConfig: &developerconnect.AccountConnectorProviderOauthConfigArgs{
				SystemProviderId: pulumi.String("GITLAB"),
				Scopes: pulumi.StringArray{
					pulumi.String("api"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.developerconnect.AccountConnector;
import com.pulumi.gcp.developerconnect.AccountConnectorArgs;
import com.pulumi.gcp.developerconnect.inputs.AccountConnectorProviderOauthConfigArgs;
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 my_account_connector = new AccountConnector("my-account-connector", AccountConnectorArgs.builder()
            .location("us-central1")
            .accountConnectorId("tf-test-ac")
            .providerOauthConfig(AccountConnectorProviderOauthConfigArgs.builder()
                .systemProviderId("GITLAB")
                .scopes("api")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  my-account-connector:
    type: gcp:developerconnect:AccountConnector
    properties:
      location: us-central1
      accountConnectorId: tf-test-ac
      providerOauthConfig:
        systemProviderId: GITLAB
        scopes:
          - api
Content copied to clipboard

Developer Connect Account Connector Google

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const my_account_connector = new gcp.developerconnect.AccountConnector("my-account-connector", {
    location: "us-central1",
    accountConnectorId: "tf-test-ac",
    providerOauthConfig: {
        systemProviderId: "GOOGLE",
        scopes: ["https://www.googleapis.com/auth/drive.readonly"],
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
my_account_connector = gcp.developerconnect.AccountConnector("my-account-connector",
    location="us-central1",
    account_connector_id="tf-test-ac",
    provider_oauth_config={
        "system_provider_id": "GOOGLE",
        "scopes": ["https://www.googleapis.com/auth/drive.readonly"],
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var my_account_connector = new Gcp.DeveloperConnect.AccountConnector("my-account-connector", new()
    {
        Location = "us-central1",
        AccountConnectorId = "tf-test-ac",
        ProviderOauthConfig = new Gcp.DeveloperConnect.Inputs.AccountConnectorProviderOauthConfigArgs
        {
            SystemProviderId = "GOOGLE",
            Scopes = new[]
            {
                "https://www.googleapis.com/auth/drive.readonly",
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/developerconnect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := developerconnect.NewAccountConnector(ctx, "my-account-connector", &developerconnect.AccountConnectorArgs{
			Location:           pulumi.String("us-central1"),
			AccountConnectorId: pulumi.String("tf-test-ac"),
			ProviderOauthConfig: &developerconnect.AccountConnectorProviderOauthConfigArgs{
				SystemProviderId: pulumi.String("GOOGLE"),
				Scopes: pulumi.StringArray{
					pulumi.String("https://www.googleapis.com/auth/drive.readonly"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.developerconnect.AccountConnector;
import com.pulumi.gcp.developerconnect.AccountConnectorArgs;
import com.pulumi.gcp.developerconnect.inputs.AccountConnectorProviderOauthConfigArgs;
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 my_account_connector = new AccountConnector("my-account-connector", AccountConnectorArgs.builder()
            .location("us-central1")
            .accountConnectorId("tf-test-ac")
            .providerOauthConfig(AccountConnectorProviderOauthConfigArgs.builder()
                .systemProviderId("GOOGLE")
                .scopes("https://www.googleapis.com/auth/drive.readonly")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  my-account-connector:
    type: gcp:developerconnect:AccountConnector
    properties:
      location: us-central1
      accountConnectorId: tf-test-ac
      providerOauthConfig:
        systemProviderId: GOOGLE
        scopes:
          - https://www.googleapis.com/auth/drive.readonly
Content copied to clipboard

Developer Connect Account Connector Sentry

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const my_account_connector = new gcp.developerconnect.AccountConnector("my-account-connector", {
    location: "us-central1",
    accountConnectorId: "tf-test-ac",
    providerOauthConfig: {
        systemProviderId: "SENTRY",
        scopes: ["org:read"],
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
my_account_connector = gcp.developerconnect.AccountConnector("my-account-connector",
    location="us-central1",
    account_connector_id="tf-test-ac",
    provider_oauth_config={
        "system_provider_id": "SENTRY",
        "scopes": ["org:read"],
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var my_account_connector = new Gcp.DeveloperConnect.AccountConnector("my-account-connector", new()
    {
        Location = "us-central1",
        AccountConnectorId = "tf-test-ac",
        ProviderOauthConfig = new Gcp.DeveloperConnect.Inputs.AccountConnectorProviderOauthConfigArgs
        {
            SystemProviderId = "SENTRY",
            Scopes = new[]
            {
                "org:read",
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/developerconnect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := developerconnect.NewAccountConnector(ctx, "my-account-connector", &developerconnect.AccountConnectorArgs{
			Location:           pulumi.String("us-central1"),
			AccountConnectorId: pulumi.String("tf-test-ac"),
			ProviderOauthConfig: &developerconnect.AccountConnectorProviderOauthConfigArgs{
				SystemProviderId: pulumi.String("SENTRY"),
				Scopes: pulumi.StringArray{
					pulumi.String("org:read"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.developerconnect.AccountConnector;
import com.pulumi.gcp.developerconnect.AccountConnectorArgs;
import com.pulumi.gcp.developerconnect.inputs.AccountConnectorProviderOauthConfigArgs;
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 my_account_connector = new AccountConnector("my-account-connector", AccountConnectorArgs.builder()
            .location("us-central1")
            .accountConnectorId("tf-test-ac")
            .providerOauthConfig(AccountConnectorProviderOauthConfigArgs.builder()
                .systemProviderId("SENTRY")
                .scopes("org:read")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  my-account-connector:
    type: gcp:developerconnect:AccountConnector
    properties:
      location: us-central1
      accountConnectorId: tf-test-ac
      providerOauthConfig:
        systemProviderId: SENTRY
        scopes:
          - org:read
Content copied to clipboard

Developer Connect Account Connector Rovo

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const my_account_connector = new gcp.developerconnect.AccountConnector("my-account-connector", {
    location: "us-central1",
    accountConnectorId: "tf-test-ac",
    providerOauthConfig: {
        systemProviderId: "ROVO",
        scopes: ["rovo"],
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
my_account_connector = gcp.developerconnect.AccountConnector("my-account-connector",
    location="us-central1",
    account_connector_id="tf-test-ac",
    provider_oauth_config={
        "system_provider_id": "ROVO",
        "scopes": ["rovo"],
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var my_account_connector = new Gcp.DeveloperConnect.AccountConnector("my-account-connector", new()
    {
        Location = "us-central1",
        AccountConnectorId = "tf-test-ac",
        ProviderOauthConfig = new Gcp.DeveloperConnect.Inputs.AccountConnectorProviderOauthConfigArgs
        {
            SystemProviderId = "ROVO",
            Scopes = new[]
            {
                "rovo",
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/developerconnect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := developerconnect.NewAccountConnector(ctx, "my-account-connector", &developerconnect.AccountConnectorArgs{
			Location:           pulumi.String("us-central1"),
			AccountConnectorId: pulumi.String("tf-test-ac"),
			ProviderOauthConfig: &developerconnect.AccountConnectorProviderOauthConfigArgs{
				SystemProviderId: pulumi.String("ROVO"),
				Scopes: pulumi.StringArray{
					pulumi.String("rovo"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.developerconnect.AccountConnector;
import com.pulumi.gcp.developerconnect.AccountConnectorArgs;
import com.pulumi.gcp.developerconnect.inputs.AccountConnectorProviderOauthConfigArgs;
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 my_account_connector = new AccountConnector("my-account-connector", AccountConnectorArgs.builder()
            .location("us-central1")
            .accountConnectorId("tf-test-ac")
            .providerOauthConfig(AccountConnectorProviderOauthConfigArgs.builder()
                .systemProviderId("ROVO")
                .scopes("rovo")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  my-account-connector:
    type: gcp:developerconnect:AccountConnector
    properties:
      location: us-central1
      accountConnectorId: tf-test-ac
      providerOauthConfig:
        systemProviderId: ROVO
        scopes:
          - rovo
Content copied to clipboard

Developer Connect Account Connector New Relic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const my_account_connector = new gcp.developerconnect.AccountConnector("my-account-connector", {
    location: "us-central1",
    accountConnectorId: "tf-test-ac",
    providerOauthConfig: {
        systemProviderId: "NEW_RELIC",
        scopes: [],
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
my_account_connector = gcp.developerconnect.AccountConnector("my-account-connector",
    location="us-central1",
    account_connector_id="tf-test-ac",
    provider_oauth_config={
        "system_provider_id": "NEW_RELIC",
        "scopes": [],
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var my_account_connector = new Gcp.DeveloperConnect.AccountConnector("my-account-connector", new()
    {
        Location = "us-central1",
        AccountConnectorId = "tf-test-ac",
        ProviderOauthConfig = new Gcp.DeveloperConnect.Inputs.AccountConnectorProviderOauthConfigArgs
        {
            SystemProviderId = "NEW_RELIC",
            Scopes = new() { },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/developerconnect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := developerconnect.NewAccountConnector(ctx, "my-account-connector", &developerconnect.AccountConnectorArgs{
			Location:           pulumi.String("us-central1"),
			AccountConnectorId: pulumi.String("tf-test-ac"),
			ProviderOauthConfig: &developerconnect.AccountConnectorProviderOauthConfigArgs{
				SystemProviderId: pulumi.String("NEW_RELIC"),
				Scopes:           pulumi.StringArray{},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.developerconnect.AccountConnector;
import com.pulumi.gcp.developerconnect.AccountConnectorArgs;
import com.pulumi.gcp.developerconnect.inputs.AccountConnectorProviderOauthConfigArgs;
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 my_account_connector = new AccountConnector("my-account-connector", AccountConnectorArgs.builder()
            .location("us-central1")
            .accountConnectorId("tf-test-ac")
            .providerOauthConfig(AccountConnectorProviderOauthConfigArgs.builder()
                .systemProviderId("NEW_RELIC")
                .scopes()
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  my-account-connector:
    type: gcp:developerconnect:AccountConnector
    properties:
      location: us-central1
      accountConnectorId: tf-test-ac
      providerOauthConfig:
        systemProviderId: NEW_RELIC
        scopes: []
Content copied to clipboard

Developer Connect Account Connector Datastax

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const my_account_connector = new gcp.developerconnect.AccountConnector("my-account-connector", {
    location: "us-central1",
    accountConnectorId: "tf-test-ac",
    providerOauthConfig: {
        systemProviderId: "DATASTAX",
        scopes: [],
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
my_account_connector = gcp.developerconnect.AccountConnector("my-account-connector",
    location="us-central1",
    account_connector_id="tf-test-ac",
    provider_oauth_config={
        "system_provider_id": "DATASTAX",
        "scopes": [],
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var my_account_connector = new Gcp.DeveloperConnect.AccountConnector("my-account-connector", new()
    {
        Location = "us-central1",
        AccountConnectorId = "tf-test-ac",
        ProviderOauthConfig = new Gcp.DeveloperConnect.Inputs.AccountConnectorProviderOauthConfigArgs
        {
            SystemProviderId = "DATASTAX",
            Scopes = new() { },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/developerconnect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := developerconnect.NewAccountConnector(ctx, "my-account-connector", &developerconnect.AccountConnectorArgs{
			Location:           pulumi.String("us-central1"),
			AccountConnectorId: pulumi.String("tf-test-ac"),
			ProviderOauthConfig: &developerconnect.AccountConnectorProviderOauthConfigArgs{
				SystemProviderId: pulumi.String("DATASTAX"),
				Scopes:           pulumi.StringArray{},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.developerconnect.AccountConnector;
import com.pulumi.gcp.developerconnect.AccountConnectorArgs;
import com.pulumi.gcp.developerconnect.inputs.AccountConnectorProviderOauthConfigArgs;
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 my_account_connector = new AccountConnector("my-account-connector", AccountConnectorArgs.builder()
            .location("us-central1")
            .accountConnectorId("tf-test-ac")
            .providerOauthConfig(AccountConnectorProviderOauthConfigArgs.builder()
                .systemProviderId("DATASTAX")
                .scopes()
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  my-account-connector:
    type: gcp:developerconnect:AccountConnector
    properties:
      location: us-central1
      accountConnectorId: tf-test-ac
      providerOauthConfig:
        systemProviderId: DATASTAX
        scopes: []
Content copied to clipboard

Import

AccountConnector can be imported using any of these accepted formats:

  • projects/{{project}}/locations/{{location}}/accountConnectors/{{account_connector_id}}

  • {{project}}/{{location}}/{{account_connector_id}}

  • {{location}}/{{account_connector_id}} When using the pulumi import command, AccountConnector can be imported using one of the formats above. For example:

$ pulumi import gcp:developerconnect/accountConnector:AccountConnector default projects/{{project}}/locations/{{location}}/accountConnectors/{{account_connector_id}}
Content copied to clipboard
$ pulumi import gcp:developerconnect/accountConnector:AccountConnector default {{project}}/{{location}}/{{account_connector_id}}
Content copied to clipboard
$ pulumi import gcp:developerconnect/accountConnector:AccountConnector default {{location}}/{{account_connector_id}}
Content copied to clipboard

Properties

Link copied to clipboard
val accountConnectorId: Output<String>

Required. The ID to use for the AccountConnector, which will become the final component of the AccountConnector's resource name. Its format should adhere to https://google.aip.dev/122#resource-id-segments Names must be unique per-project per-location.

Link copied to clipboard
val annotations: Output<Map<String, String>>?

Optional. Allows users to store small amounts of arbitrary data. Note: This field is non-authoritative, and will only manage the annotations present in your configuration. Please refer to the field effective_annotations for all of the annotations present on the resource.

Link copied to clipboard
val createTime: Output<String>

Output only. The timestamp when the userConnection was created.

Link copied to clipboard
Link copied to clipboard
val effectiveLabels: Output<Map<String, String>>

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val labels: Output<Map<String, String>>?

Optional. Labels as key value pairs Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.

Link copied to clipboard
val location: Output<String>

The location of the resource.

Link copied to clipboard
val name: Output<String>

Identifier. The resource name of the userConnection, in the format projects/{project}/locations/{location}/accountConnectors/{account_connector_id}.

Link copied to clipboard
val oauthStartUri: Output<String>

Output only. Start OAuth flow by clicking on this URL.

Link copied to clipboard
val project: Output<String>

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

Link copied to clipboard
val providerOauthConfig: Output<AccountConnectorProviderOauthConfig>?

ProviderOAuthConfig is the OAuth config for a provider. Structure is documented below.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
val pulumiLabels: Output<Map<String, String>>

The combination of labels configured directly on the resource and default labels configured on the provider.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val updateTime: Output<String>

Output only. The timestamp when the userConnection was updated.

Link copied to clipboard
val urn: Output<String>