Connection
An Integration connectors Connection. To get more information about Connection, see:
How-to Guides
Example Usage
Integration Connectors Connection Basic
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const testProject = gcp.organizations.getProject({});
const pubsubconnection = new gcp.integrationconnectors.Connection("pubsubconnection", {
name: "test-pubsub",
location: "us-central1",
connectorVersion: testProject.then(testProject => `projects/${testProject.projectId}/locations/global/providers/gcp/connectors/pubsub/versions/1`),
description: "tf created description",
configVariables: [
{
key: "project_id",
stringValue: "connectors-example",
},
{
key: "topic_id",
stringValue: "test",
},
],
});Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
test_project = gcp.organizations.get_project()
pubsubconnection = gcp.integrationconnectors.Connection("pubsubconnection",
name="test-pubsub",
location="us-central1",
connector_version=f"projects/{test_project.project_id}/locations/global/providers/gcp/connectors/pubsub/versions/1",
description="tf created description",
config_variables=[
{
"key": "project_id",
"string_value": "connectors-example",
},
{
"key": "topic_id",
"string_value": "test",
},
])Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
var testProject = Gcp.Organizations.GetProject.Invoke();
var pubsubconnection = new Gcp.IntegrationConnectors.Connection("pubsubconnection", new()
{
Name = "test-pubsub",
Location = "us-central1",
ConnectorVersion = $"projects/{testProject.Apply(getProjectResult => getProjectResult.ProjectId)}/locations/global/providers/gcp/connectors/pubsub/versions/1",
Description = "tf created description",
ConfigVariables = new[]
{
new Gcp.IntegrationConnectors.Inputs.ConnectionConfigVariableArgs
{
Key = "project_id",
StringValue = "connectors-example",
},
new Gcp.IntegrationConnectors.Inputs.ConnectionConfigVariableArgs
{
Key = "topic_id",
StringValue = "test",
},
},
});
});Content copied to clipboard
package main
import (
"fmt"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/integrationconnectors"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
testProject, err := organizations.LookupProject(ctx, nil, nil)
if err != nil {
return err
}
_, err = integrationconnectors.NewConnection(ctx, "pubsubconnection", &integrationconnectors.ConnectionArgs{
Name: pulumi.String("test-pubsub"),
Location: pulumi.String("us-central1"),
ConnectorVersion: pulumi.Sprintf("projects/%v/locations/global/providers/gcp/connectors/pubsub/versions/1", testProject.ProjectId),
Description: pulumi.String("tf created description"),
ConfigVariables: integrationconnectors.ConnectionConfigVariableArray{
&integrationconnectors.ConnectionConfigVariableArgs{
Key: pulumi.String("project_id"),
StringValue: pulumi.String("connectors-example"),
},
&integrationconnectors.ConnectionConfigVariableArgs{
Key: pulumi.String("topic_id"),
StringValue: pulumi.String("test"),
},
},
})
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.organizations.OrganizationsFunctions;
import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
import com.pulumi.gcp.integrationconnectors.Connection;
import com.pulumi.gcp.integrationconnectors.ConnectionArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionConfigVariableArgs;
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 testProject = OrganizationsFunctions.getProject();
var pubsubconnection = new Connection("pubsubconnection", ConnectionArgs.builder()
.name("test-pubsub")
.location("us-central1")
.connectorVersion(String.format("projects/%s/locations/global/providers/gcp/connectors/pubsub/versions/1", testProject.applyValue(getProjectResult -> getProjectResult.projectId())))
.description("tf created description")
.configVariables(
ConnectionConfigVariableArgs.builder()
.key("project_id")
.stringValue("connectors-example")
.build(),
ConnectionConfigVariableArgs.builder()
.key("topic_id")
.stringValue("test")
.build())
.build());
}
}Content copied to clipboard
resources:
pubsubconnection:
type: gcp:integrationconnectors:Connection
properties:
name: test-pubsub
location: us-central1
connectorVersion: projects/${testProject.projectId}/locations/global/providers/gcp/connectors/pubsub/versions/1
description: tf created description
configVariables:
- key: project_id
stringValue: connectors-example
- key: topic_id
stringValue: test
variables:
testProject:
fn::invoke:
Function: gcp:organizations:getProject
Arguments: {}Content copied to clipboard
Integration Connectors Connection Advanced
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const testProject = gcp.organizations.getProject({});
const secret_basic = new gcp.secretmanager.Secret("secret-basic", {
secretId: "test-secret",
replication: {
userManaged: {
replicas: [{
location: "us-central1",
}],
},
},
});
const secret_version_basic = new gcp.secretmanager.SecretVersion("secret-version-basic", {
secret: secret_basic.id,
secretData: "dummypassword",
});
const secretIam = new gcp.secretmanager.SecretIamMember("secret_iam", {
secretId: secret_basic.id,
role: "roles/secretmanager.admin",
member: testProject.then(testProject => `serviceAccount:${testProject.number}-compute@developer.gserviceaccount.com`),
}, {
dependsOn: [secret_version_basic],
});
const zendeskconnection = new gcp.integrationconnectors.Connection("zendeskconnection", {
name: "test-zendesk",
description: "tf updated description",
location: "us-central1",
serviceAccount: testProject.then(testProject => `${testProject.number}-compute@developer.gserviceaccount.com`),
connectorVersion: testProject.then(testProject => `projects/${testProject.projectId}/locations/global/providers/zendesk/connectors/zendesk/versions/1`),
configVariables: [
{
key: "proxy_enabled",
booleanValue: false,
},
{
key: "sample_integer_value",
integerValue: 1,
},
{
key: "sample_encryption_key_value",
encryptionKeyValue: {
type: "GOOGLE_MANAGED",
kmsKeyName: "sampleKMSKkey",
},
},
{
key: "sample_secret_value",
secretValue: {
secretVersion: secret_version_basic.name,
},
},
],
suspended: false,
authConfig: {
additionalVariables: [
{
key: "sample_string",
stringValue: "sampleString",
},
{
key: "sample_boolean",
booleanValue: false,
},
{
key: "sample_integer",
integerValue: 1,
},
{
key: "sample_secret_value",
secretValue: {
secretVersion: secret_version_basic.name,
},
},
{
key: "sample_encryption_key_value",
encryptionKeyValue: {
type: "GOOGLE_MANAGED",
kmsKeyName: "sampleKMSKkey",
},
},
],
authType: "USER_PASSWORD",
authKey: "sampleAuthKey",
userPassword: {
username: "user@xyz.com",
password: {
secretVersion: secret_version_basic.name,
},
},
},
destinationConfigs: [{
key: "url",
destinations: [{
host: "https://test.zendesk.com",
port: 80,
}],
}],
lockConfig: {
locked: false,
reason: "Its not locked",
},
logConfig: {
enabled: true,
},
nodeConfig: {
minNodeCount: 2,
maxNodeCount: 50,
},
labels: {
foo: "bar",
},
sslConfig: {
additionalVariables: [
{
key: "sample_string",
stringValue: "sampleString",
},
{
key: "sample_boolean",
booleanValue: false,
},
{
key: "sample_integer",
integerValue: 1,
},
{
key: "sample_secret_value",
secretValue: {
secretVersion: secret_version_basic.name,
},
},
{
key: "sample_encryption_key_value",
encryptionKeyValue: {
type: "GOOGLE_MANAGED",
kmsKeyName: "sampleKMSKkey",
},
},
],
clientCertType: "PEM",
clientCertificate: {
secretVersion: secret_version_basic.name,
},
clientPrivateKey: {
secretVersion: secret_version_basic.name,
},
clientPrivateKeyPass: {
secretVersion: secret_version_basic.name,
},
privateServerCertificate: {
secretVersion: secret_version_basic.name,
},
serverCertType: "PEM",
trustModel: "PRIVATE",
type: "TLS",
useSsl: true,
},
eventingEnablementType: "EVENTING_AND_CONNECTION",
eventingConfig: {
additionalVariables: [
{
key: "sample_string",
stringValue: "sampleString",
},
{
key: "sample_boolean",
booleanValue: false,
},
{
key: "sample_integer",
integerValue: 1,
},
{
key: "sample_secret_value",
secretValue: {
secretVersion: secret_version_basic.name,
},
},
{
key: "sample_encryption_key_value",
encryptionKeyValue: {
type: "GOOGLE_MANAGED",
kmsKeyName: "sampleKMSKkey",
},
},
],
registrationDestinationConfig: {
key: "registration_destination_config",
destinations: [{
host: "https://test.zendesk.com",
port: 80,
}],
},
authConfig: {
authType: "USER_PASSWORD",
authKey: "sampleAuthKey",
userPassword: {
username: "user@xyz.com",
password: {
secretVersion: secret_version_basic.name,
},
},
additionalVariables: [
{
key: "sample_string",
stringValue: "sampleString",
},
{
key: "sample_boolean",
booleanValue: false,
},
{
key: "sample_integer",
integerValue: 1,
},
{
key: "sample_secret_value",
secretValue: {
secretVersion: secret_version_basic.name,
},
},
{
key: "sample_encryption_key_value",
encryptionKeyValue: {
type: "GOOGLE_MANAGED",
kmsKeyName: "sampleKMSKkey",
},
},
],
},
enrichmentEnabled: true,
},
});Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
test_project = gcp.organizations.get_project()
secret_basic = gcp.secretmanager.Secret("secret-basic",
secret_id="test-secret",
replication={
"user_managed": {
"replicas": [{
"location": "us-central1",
}],
},
})
secret_version_basic = gcp.secretmanager.SecretVersion("secret-version-basic",
secret=secret_basic.id,
secret_data="dummypassword")
secret_iam = gcp.secretmanager.SecretIamMember("secret_iam",
secret_id=secret_basic.id,
role="roles/secretmanager.admin",
member=f"serviceAccount:{test_project.number}-compute@developer.gserviceaccount.com",
opts = pulumi.ResourceOptions(depends_on=[secret_version_basic]))
zendeskconnection = gcp.integrationconnectors.Connection("zendeskconnection",
name="test-zendesk",
description="tf updated description",
location="us-central1",
service_account=f"{test_project.number}-compute@developer.gserviceaccount.com",
connector_version=f"projects/{test_project.project_id}/locations/global/providers/zendesk/connectors/zendesk/versions/1",
config_variables=[
{
"key": "proxy_enabled",
"boolean_value": False,
},
{
"key": "sample_integer_value",
"integer_value": 1,
},
{
"key": "sample_encryption_key_value",
"encryption_key_value": {
"type": "GOOGLE_MANAGED",
"kms_key_name": "sampleKMSKkey",
},
},
{
"key": "sample_secret_value",
"secret_value": {
"secret_version": secret_version_basic.name,
},
},
],
suspended=False,
auth_config={
"additional_variables": [
{
"key": "sample_string",
"string_value": "sampleString",
},
{
"key": "sample_boolean",
"boolean_value": False,
},
{
"key": "sample_integer",
"integer_value": 1,
},
{
"key": "sample_secret_value",
"secret_value": {
"secret_version": secret_version_basic.name,
},
},
{
"key": "sample_encryption_key_value",
"encryption_key_value": {
"type": "GOOGLE_MANAGED",
"kms_key_name": "sampleKMSKkey",
},
},
],
"auth_type": "USER_PASSWORD",
"auth_key": "sampleAuthKey",
"user_password": {
"username": "user@xyz.com",
"password": {
"secret_version": secret_version_basic.name,
},
},
},
destination_configs=[{
"key": "url",
"destinations": [{
"host": "https://test.zendesk.com",
"port": 80,
}],
}],
lock_config={
"locked": False,
"reason": "Its not locked",
},
log_config={
"enabled": True,
},
node_config={
"min_node_count": 2,
"max_node_count": 50,
},
labels={
"foo": "bar",
},
ssl_config={
"additional_variables": [
{
"key": "sample_string",
"string_value": "sampleString",
},
{
"key": "sample_boolean",
"boolean_value": False,
},
{
"key": "sample_integer",
"integer_value": 1,
},
{
"key": "sample_secret_value",
"secret_value": {
"secret_version": secret_version_basic.name,
},
},
{
"key": "sample_encryption_key_value",
"encryption_key_value": {
"type": "GOOGLE_MANAGED",
"kms_key_name": "sampleKMSKkey",
},
},
],
"client_cert_type": "PEM",
"client_certificate": {
"secret_version": secret_version_basic.name,
},
"client_private_key": {
"secret_version": secret_version_basic.name,
},
"client_private_key_pass": {
"secret_version": secret_version_basic.name,
},
"private_server_certificate": {
"secret_version": secret_version_basic.name,
},
"server_cert_type": "PEM",
"trust_model": "PRIVATE",
"type": "TLS",
"use_ssl": True,
},
eventing_enablement_type="EVENTING_AND_CONNECTION",
eventing_config={
"additional_variables": [
{
"key": "sample_string",
"string_value": "sampleString",
},
{
"key": "sample_boolean",
"boolean_value": False,
},
{
"key": "sample_integer",
"integer_value": 1,
},
{
"key": "sample_secret_value",
"secret_value": {
"secret_version": secret_version_basic.name,
},
},
{
"key": "sample_encryption_key_value",
"encryption_key_value": {
"type": "GOOGLE_MANAGED",
"kms_key_name": "sampleKMSKkey",
},
},
],
"registration_destination_config": {
"key": "registration_destination_config",
"destinations": [{
"host": "https://test.zendesk.com",
"port": 80,
}],
},
"auth_config": {
"auth_type": "USER_PASSWORD",
"auth_key": "sampleAuthKey",
"user_password": {
"username": "user@xyz.com",
"password": {
"secret_version": secret_version_basic.name,
},
},
"additional_variables": [
{
"key": "sample_string",
"string_value": "sampleString",
},
{
"key": "sample_boolean",
"boolean_value": False,
},
{
"key": "sample_integer",
"integer_value": 1,
},
{
"key": "sample_secret_value",
"secret_value": {
"secret_version": secret_version_basic.name,
},
},
{
"key": "sample_encryption_key_value",
"encryption_key_value": {
"type": "GOOGLE_MANAGED",
"kms_key_name": "sampleKMSKkey",
},
},
],
},
"enrichment_enabled": True,
})Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
var testProject = Gcp.Organizations.GetProject.Invoke();
var secret_basic = new Gcp.SecretManager.Secret("secret-basic", new()
{
SecretId = "test-secret",
Replication = new Gcp.SecretManager.Inputs.SecretReplicationArgs
{
UserManaged = new Gcp.SecretManager.Inputs.SecretReplicationUserManagedArgs
{
Replicas = new[]
{
new Gcp.SecretManager.Inputs.SecretReplicationUserManagedReplicaArgs
{
Location = "us-central1",
},
},
},
},
});
var secret_version_basic = new Gcp.SecretManager.SecretVersion("secret-version-basic", new()
{
Secret = secret_basic.Id,
SecretData = "dummypassword",
});
var secretIam = new Gcp.SecretManager.SecretIamMember("secret_iam", new()
{
SecretId = secret_basic.Id,
Role = "roles/secretmanager.admin",
Member = $"serviceAccount:{testProject.Apply(getProjectResult => getProjectResult.Number)}-compute@developer.gserviceaccount.com",
}, new CustomResourceOptions
{
DependsOn =
{
secret_version_basic,
},
});
var zendeskconnection = new Gcp.IntegrationConnectors.Connection("zendeskconnection", new()
{
Name = "test-zendesk",
Description = "tf updated description",
Location = "us-central1",
ServiceAccount = $"{testProject.Apply(getProjectResult => getProjectResult.Number)}-compute@developer.gserviceaccount.com",
ConnectorVersion = $"projects/{testProject.Apply(getProjectResult => getProjectResult.ProjectId)}/locations/global/providers/zendesk/connectors/zendesk/versions/1",
ConfigVariables = new[]
{
new Gcp.IntegrationConnectors.Inputs.ConnectionConfigVariableArgs
{
Key = "proxy_enabled",
BooleanValue = false,
},
new Gcp.IntegrationConnectors.Inputs.ConnectionConfigVariableArgs
{
Key = "sample_integer_value",
IntegerValue = 1,
},
new Gcp.IntegrationConnectors.Inputs.ConnectionConfigVariableArgs
{
Key = "sample_encryption_key_value",
EncryptionKeyValue = new Gcp.IntegrationConnectors.Inputs.ConnectionConfigVariableEncryptionKeyValueArgs
{
Type = "GOOGLE_MANAGED",
KmsKeyName = "sampleKMSKkey",
},
},
new Gcp.IntegrationConnectors.Inputs.ConnectionConfigVariableArgs
{
Key = "sample_secret_value",
SecretValue = new Gcp.IntegrationConnectors.Inputs.ConnectionConfigVariableSecretValueArgs
{
SecretVersion = secret_version_basic.Name,
},
},
},
Suspended = false,
AuthConfig = new Gcp.IntegrationConnectors.Inputs.ConnectionAuthConfigArgs
{
AdditionalVariables = new[]
{
new Gcp.IntegrationConnectors.Inputs.ConnectionAuthConfigAdditionalVariableArgs
{
Key = "sample_string",
StringValue = "sampleString",
},
new Gcp.IntegrationConnectors.Inputs.ConnectionAuthConfigAdditionalVariableArgs
{
Key = "sample_boolean",
BooleanValue = false,
},
new Gcp.IntegrationConnectors.Inputs.ConnectionAuthConfigAdditionalVariableArgs
{
Key = "sample_integer",
IntegerValue = 1,
},
new Gcp.IntegrationConnectors.Inputs.ConnectionAuthConfigAdditionalVariableArgs
{
Key = "sample_secret_value",
SecretValue = new Gcp.IntegrationConnectors.Inputs.ConnectionAuthConfigAdditionalVariableSecretValueArgs
{
SecretVersion = secret_version_basic.Name,
},
},
new Gcp.IntegrationConnectors.Inputs.ConnectionAuthConfigAdditionalVariableArgs
{
Key = "sample_encryption_key_value",
EncryptionKeyValue = new Gcp.IntegrationConnectors.Inputs.ConnectionAuthConfigAdditionalVariableEncryptionKeyValueArgs
{
Type = "GOOGLE_MANAGED",
KmsKeyName = "sampleKMSKkey",
},
},
},
AuthType = "USER_PASSWORD",
AuthKey = "sampleAuthKey",
UserPassword = new Gcp.IntegrationConnectors.Inputs.ConnectionAuthConfigUserPasswordArgs
{
Username = "user@xyz.com",
Password = new Gcp.IntegrationConnectors.Inputs.ConnectionAuthConfigUserPasswordPasswordArgs
{
SecretVersion = secret_version_basic.Name,
},
},
},
DestinationConfigs = new[]
{
new Gcp.IntegrationConnectors.Inputs.ConnectionDestinationConfigArgs
{
Key = "url",
Destinations = new[]
{
new Gcp.IntegrationConnectors.Inputs.ConnectionDestinationConfigDestinationArgs
{
Host = "https://test.zendesk.com",
Port = 80,
},
},
},
},
LockConfig = new Gcp.IntegrationConnectors.Inputs.ConnectionLockConfigArgs
{
Locked = false,
Reason = "Its not locked",
},
LogConfig = new Gcp.IntegrationConnectors.Inputs.ConnectionLogConfigArgs
{
Enabled = true,
},
NodeConfig = new Gcp.IntegrationConnectors.Inputs.ConnectionNodeConfigArgs
{
MinNodeCount = 2,
MaxNodeCount = 50,
},
Labels =
{
{ "foo", "bar" },
},
SslConfig = new Gcp.IntegrationConnectors.Inputs.ConnectionSslConfigArgs
{
AdditionalVariables = new[]
{
new Gcp.IntegrationConnectors.Inputs.ConnectionSslConfigAdditionalVariableArgs
{
Key = "sample_string",
StringValue = "sampleString",
},
new Gcp.IntegrationConnectors.Inputs.ConnectionSslConfigAdditionalVariableArgs
{
Key = "sample_boolean",
BooleanValue = false,
},
new Gcp.IntegrationConnectors.Inputs.ConnectionSslConfigAdditionalVariableArgs
{
Key = "sample_integer",
IntegerValue = 1,
},
new Gcp.IntegrationConnectors.Inputs.ConnectionSslConfigAdditionalVariableArgs
{
Key = "sample_secret_value",
SecretValue = new Gcp.IntegrationConnectors.Inputs.ConnectionSslConfigAdditionalVariableSecretValueArgs
{
SecretVersion = secret_version_basic.Name,
},
},
new Gcp.IntegrationConnectors.Inputs.ConnectionSslConfigAdditionalVariableArgs
{
Key = "sample_encryption_key_value",
EncryptionKeyValue = new Gcp.IntegrationConnectors.Inputs.ConnectionSslConfigAdditionalVariableEncryptionKeyValueArgs
{
Type = "GOOGLE_MANAGED",
KmsKeyName = "sampleKMSKkey",
},
},
},
ClientCertType = "PEM",
ClientCertificate = new Gcp.IntegrationConnectors.Inputs.ConnectionSslConfigClientCertificateArgs
{
SecretVersion = secret_version_basic.Name,
},
ClientPrivateKey = new Gcp.IntegrationConnectors.Inputs.ConnectionSslConfigClientPrivateKeyArgs
{
SecretVersion = secret_version_basic.Name,
},
ClientPrivateKeyPass = new Gcp.IntegrationConnectors.Inputs.ConnectionSslConfigClientPrivateKeyPassArgs
{
SecretVersion = secret_version_basic.Name,
},
PrivateServerCertificate = new Gcp.IntegrationConnectors.Inputs.ConnectionSslConfigPrivateServerCertificateArgs
{
SecretVersion = secret_version_basic.Name,
},
ServerCertType = "PEM",
TrustModel = "PRIVATE",
Type = "TLS",
UseSsl = true,
},
EventingEnablementType = "EVENTING_AND_CONNECTION",
EventingConfig = new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigArgs
{
AdditionalVariables = new[]
{
new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigAdditionalVariableArgs
{
Key = "sample_string",
StringValue = "sampleString",
},
new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigAdditionalVariableArgs
{
Key = "sample_boolean",
BooleanValue = false,
},
new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigAdditionalVariableArgs
{
Key = "sample_integer",
IntegerValue = 1,
},
new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigAdditionalVariableArgs
{
Key = "sample_secret_value",
SecretValue = new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigAdditionalVariableSecretValueArgs
{
SecretVersion = secret_version_basic.Name,
},
},
new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigAdditionalVariableArgs
{
Key = "sample_encryption_key_value",
EncryptionKeyValue = new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigAdditionalVariableEncryptionKeyValueArgs
{
Type = "GOOGLE_MANAGED",
KmsKeyName = "sampleKMSKkey",
},
},
},
RegistrationDestinationConfig = new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigRegistrationDestinationConfigArgs
{
Key = "registration_destination_config",
Destinations = new[]
{
new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigRegistrationDestinationConfigDestinationArgs
{
Host = "https://test.zendesk.com",
Port = 80,
},
},
},
AuthConfig = new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigAuthConfigArgs
{
AuthType = "USER_PASSWORD",
AuthKey = "sampleAuthKey",
UserPassword = new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigAuthConfigUserPasswordArgs
{
Username = "user@xyz.com",
Password = new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigAuthConfigUserPasswordPasswordArgs
{
SecretVersion = secret_version_basic.Name,
},
},
AdditionalVariables = new[]
{
new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigAuthConfigAdditionalVariableArgs
{
Key = "sample_string",
StringValue = "sampleString",
},
new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigAuthConfigAdditionalVariableArgs
{
Key = "sample_boolean",
BooleanValue = false,
},
new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigAuthConfigAdditionalVariableArgs
{
Key = "sample_integer",
IntegerValue = 1,
},
new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigAuthConfigAdditionalVariableArgs
{
Key = "sample_secret_value",
SecretValue = new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigAuthConfigAdditionalVariableSecretValueArgs
{
SecretVersion = secret_version_basic.Name,
},
},
new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigAuthConfigAdditionalVariableArgs
{
Key = "sample_encryption_key_value",
EncryptionKeyValue = new Gcp.IntegrationConnectors.Inputs.ConnectionEventingConfigAuthConfigAdditionalVariableEncryptionKeyValueArgs
{
Type = "GOOGLE_MANAGED",
KmsKeyName = "sampleKMSKkey",
},
},
},
},
EnrichmentEnabled = true,
},
});
});Content copied to clipboard
package main
import (
"fmt"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/integrationconnectors"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/secretmanager"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
testProject, err := organizations.LookupProject(ctx, nil, nil)
if err != nil {
return err
}
_, err = secretmanager.NewSecret(ctx, "secret-basic", &secretmanager.SecretArgs{
SecretId: pulumi.String("test-secret"),
Replication: &secretmanager.SecretReplicationArgs{
UserManaged: &secretmanager.SecretReplicationUserManagedArgs{
Replicas: secretmanager.SecretReplicationUserManagedReplicaArray{
&secretmanager.SecretReplicationUserManagedReplicaArgs{
Location: pulumi.String("us-central1"),
},
},
},
},
})
if err != nil {
return err
}
_, err = secretmanager.NewSecretVersion(ctx, "secret-version-basic", &secretmanager.SecretVersionArgs{
Secret: secret_basic.ID(),
SecretData: pulumi.String("dummypassword"),
})
if err != nil {
return err
}
_, err = secretmanager.NewSecretIamMember(ctx, "secret_iam", &secretmanager.SecretIamMemberArgs{
SecretId: secret_basic.ID(),
Role: pulumi.String("roles/secretmanager.admin"),
Member: pulumi.Sprintf("serviceAccount:%v-compute@developer.gserviceaccount.com", testProject.Number),
}, pulumi.DependsOn([]pulumi.Resource{
secret_version_basic,
}))
if err != nil {
return err
}
_, err = integrationconnectors.NewConnection(ctx, "zendeskconnection", &integrationconnectors.ConnectionArgs{
Name: pulumi.String("test-zendesk"),
Description: pulumi.String("tf updated description"),
Location: pulumi.String("us-central1"),
ServiceAccount: pulumi.Sprintf("%v-compute@developer.gserviceaccount.com", testProject.Number),
ConnectorVersion: pulumi.Sprintf("projects/%v/locations/global/providers/zendesk/connectors/zendesk/versions/1", testProject.ProjectId),
ConfigVariables: integrationconnectors.ConnectionConfigVariableArray{
&integrationconnectors.ConnectionConfigVariableArgs{
Key: pulumi.String("proxy_enabled"),
BooleanValue: pulumi.Bool(false),
},
&integrationconnectors.ConnectionConfigVariableArgs{
Key: pulumi.String("sample_integer_value"),
IntegerValue: pulumi.Int(1),
},
&integrationconnectors.ConnectionConfigVariableArgs{
Key: pulumi.String("sample_encryption_key_value"),
EncryptionKeyValue: &integrationconnectors.ConnectionConfigVariableEncryptionKeyValueArgs{
Type: pulumi.String("GOOGLE_MANAGED"),
KmsKeyName: pulumi.String("sampleKMSKkey"),
},
},
&integrationconnectors.ConnectionConfigVariableArgs{
Key: pulumi.String("sample_secret_value"),
SecretValue: &integrationconnectors.ConnectionConfigVariableSecretValueArgs{
SecretVersion: secret_version_basic.Name,
},
},
},
Suspended: pulumi.Bool(false),
AuthConfig: &integrationconnectors.ConnectionAuthConfigArgs{
AdditionalVariables: integrationconnectors.ConnectionAuthConfigAdditionalVariableArray{
&integrationconnectors.ConnectionAuthConfigAdditionalVariableArgs{
Key: pulumi.String("sample_string"),
StringValue: pulumi.String("sampleString"),
},
&integrationconnectors.ConnectionAuthConfigAdditionalVariableArgs{
Key: pulumi.String("sample_boolean"),
BooleanValue: pulumi.Bool(false),
},
&integrationconnectors.ConnectionAuthConfigAdditionalVariableArgs{
Key: pulumi.String("sample_integer"),
IntegerValue: pulumi.Int(1),
},
&integrationconnectors.ConnectionAuthConfigAdditionalVariableArgs{
Key: pulumi.String("sample_secret_value"),
SecretValue: &integrationconnectors.ConnectionAuthConfigAdditionalVariableSecretValueArgs{
SecretVersion: secret_version_basic.Name,
},
},
&integrationconnectors.ConnectionAuthConfigAdditionalVariableArgs{
Key: pulumi.String("sample_encryption_key_value"),
EncryptionKeyValue: &integrationconnectors.ConnectionAuthConfigAdditionalVariableEncryptionKeyValueArgs{
Type: pulumi.String("GOOGLE_MANAGED"),
KmsKeyName: pulumi.String("sampleKMSKkey"),
},
},
},
AuthType: pulumi.String("USER_PASSWORD"),
AuthKey: pulumi.String("sampleAuthKey"),
UserPassword: &integrationconnectors.ConnectionAuthConfigUserPasswordArgs{
Username: pulumi.String("user@xyz.com"),
Password: &integrationconnectors.ConnectionAuthConfigUserPasswordPasswordArgs{
SecretVersion: secret_version_basic.Name,
},
},
},
DestinationConfigs: integrationconnectors.ConnectionDestinationConfigArray{
&integrationconnectors.ConnectionDestinationConfigArgs{
Key: pulumi.String("url"),
Destinations: integrationconnectors.ConnectionDestinationConfigDestinationArray{
&integrationconnectors.ConnectionDestinationConfigDestinationArgs{
Host: pulumi.String("https://test.zendesk.com"),
Port: pulumi.Int(80),
},
},
},
},
LockConfig: &integrationconnectors.ConnectionLockConfigArgs{
Locked: pulumi.Bool(false),
Reason: pulumi.String("Its not locked"),
},
LogConfig: &integrationconnectors.ConnectionLogConfigArgs{
Enabled: pulumi.Bool(true),
},
NodeConfig: &integrationconnectors.ConnectionNodeConfigArgs{
MinNodeCount: pulumi.Int(2),
MaxNodeCount: pulumi.Int(50),
},
Labels: pulumi.StringMap{
"foo": pulumi.String("bar"),
},
SslConfig: &integrationconnectors.ConnectionSslConfigArgs{
AdditionalVariables: integrationconnectors.ConnectionSslConfigAdditionalVariableArray{
&integrationconnectors.ConnectionSslConfigAdditionalVariableArgs{
Key: pulumi.String("sample_string"),
StringValue: pulumi.String("sampleString"),
},
&integrationconnectors.ConnectionSslConfigAdditionalVariableArgs{
Key: pulumi.String("sample_boolean"),
BooleanValue: pulumi.Bool(false),
},
&integrationconnectors.ConnectionSslConfigAdditionalVariableArgs{
Key: pulumi.String("sample_integer"),
IntegerValue: pulumi.Int(1),
},
&integrationconnectors.ConnectionSslConfigAdditionalVariableArgs{
Key: pulumi.String("sample_secret_value"),
SecretValue: &integrationconnectors.ConnectionSslConfigAdditionalVariableSecretValueArgs{
SecretVersion: secret_version_basic.Name,
},
},
&integrationconnectors.ConnectionSslConfigAdditionalVariableArgs{
Key: pulumi.String("sample_encryption_key_value"),
EncryptionKeyValue: &integrationconnectors.ConnectionSslConfigAdditionalVariableEncryptionKeyValueArgs{
Type: pulumi.String("GOOGLE_MANAGED"),
KmsKeyName: pulumi.String("sampleKMSKkey"),
},
},
},
ClientCertType: pulumi.String("PEM"),
ClientCertificate: &integrationconnectors.ConnectionSslConfigClientCertificateArgs{
SecretVersion: secret_version_basic.Name,
},
ClientPrivateKey: &integrationconnectors.ConnectionSslConfigClientPrivateKeyArgs{
SecretVersion: secret_version_basic.Name,
},
ClientPrivateKeyPass: &integrationconnectors.ConnectionSslConfigClientPrivateKeyPassArgs{
SecretVersion: secret_version_basic.Name,
},
PrivateServerCertificate: &integrationconnectors.ConnectionSslConfigPrivateServerCertificateArgs{
SecretVersion: secret_version_basic.Name,
},
ServerCertType: pulumi.String("PEM"),
TrustModel: pulumi.String("PRIVATE"),
Type: pulumi.String("TLS"),
UseSsl: pulumi.Bool(true),
},
EventingEnablementType: pulumi.String("EVENTING_AND_CONNECTION"),
EventingConfig: &integrationconnectors.ConnectionEventingConfigArgs{
AdditionalVariables: integrationconnectors.ConnectionEventingConfigAdditionalVariableArray{
&integrationconnectors.ConnectionEventingConfigAdditionalVariableArgs{
Key: pulumi.String("sample_string"),
StringValue: pulumi.String("sampleString"),
},
&integrationconnectors.ConnectionEventingConfigAdditionalVariableArgs{
Key: pulumi.String("sample_boolean"),
BooleanValue: pulumi.Bool(false),
},
&integrationconnectors.ConnectionEventingConfigAdditionalVariableArgs{
Key: pulumi.String("sample_integer"),
IntegerValue: pulumi.Int(1),
},
&integrationconnectors.ConnectionEventingConfigAdditionalVariableArgs{
Key: pulumi.String("sample_secret_value"),
SecretValue: &integrationconnectors.ConnectionEventingConfigAdditionalVariableSecretValueArgs{
SecretVersion: secret_version_basic.Name,
},
},
&integrationconnectors.ConnectionEventingConfigAdditionalVariableArgs{
Key: pulumi.String("sample_encryption_key_value"),
EncryptionKeyValue: &integrationconnectors.ConnectionEventingConfigAdditionalVariableEncryptionKeyValueArgs{
Type: pulumi.String("GOOGLE_MANAGED"),
KmsKeyName: pulumi.String("sampleKMSKkey"),
},
},
},
RegistrationDestinationConfig: &integrationconnectors.ConnectionEventingConfigRegistrationDestinationConfigArgs{
Key: pulumi.String("registration_destination_config"),
Destinations: integrationconnectors.ConnectionEventingConfigRegistrationDestinationConfigDestinationArray{
&integrationconnectors.ConnectionEventingConfigRegistrationDestinationConfigDestinationArgs{
Host: pulumi.String("https://test.zendesk.com"),
Port: pulumi.Int(80),
},
},
},
AuthConfig: &integrationconnectors.ConnectionEventingConfigAuthConfigArgs{
AuthType: pulumi.String("USER_PASSWORD"),
AuthKey: pulumi.String("sampleAuthKey"),
UserPassword: &integrationconnectors.ConnectionEventingConfigAuthConfigUserPasswordArgs{
Username: pulumi.String("user@xyz.com"),
Password: &integrationconnectors.ConnectionEventingConfigAuthConfigUserPasswordPasswordArgs{
SecretVersion: secret_version_basic.Name,
},
},
AdditionalVariables: integrationconnectors.ConnectionEventingConfigAuthConfigAdditionalVariableArray{
&integrationconnectors.ConnectionEventingConfigAuthConfigAdditionalVariableArgs{
Key: pulumi.String("sample_string"),
StringValue: pulumi.String("sampleString"),
},
&integrationconnectors.ConnectionEventingConfigAuthConfigAdditionalVariableArgs{
Key: pulumi.String("sample_boolean"),
BooleanValue: pulumi.Bool(false),
},
&integrationconnectors.ConnectionEventingConfigAuthConfigAdditionalVariableArgs{
Key: pulumi.String("sample_integer"),
IntegerValue: pulumi.Int(1),
},
&integrationconnectors.ConnectionEventingConfigAuthConfigAdditionalVariableArgs{
Key: pulumi.String("sample_secret_value"),
SecretValue: &integrationconnectors.ConnectionEventingConfigAuthConfigAdditionalVariableSecretValueArgs{
SecretVersion: secret_version_basic.Name,
},
},
&integrationconnectors.ConnectionEventingConfigAuthConfigAdditionalVariableArgs{
Key: pulumi.String("sample_encryption_key_value"),
EncryptionKeyValue: &integrationconnectors.ConnectionEventingConfigAuthConfigAdditionalVariableEncryptionKeyValueArgs{
Type: pulumi.String("GOOGLE_MANAGED"),
KmsKeyName: pulumi.String("sampleKMSKkey"),
},
},
},
},
EnrichmentEnabled: pulumi.Bool(true),
},
})
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.organizations.OrganizationsFunctions;
import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
import com.pulumi.gcp.secretmanager.Secret;
import com.pulumi.gcp.secretmanager.SecretArgs;
import com.pulumi.gcp.secretmanager.inputs.SecretReplicationArgs;
import com.pulumi.gcp.secretmanager.inputs.SecretReplicationUserManagedArgs;
import com.pulumi.gcp.secretmanager.SecretVersion;
import com.pulumi.gcp.secretmanager.SecretVersionArgs;
import com.pulumi.gcp.secretmanager.SecretIamMember;
import com.pulumi.gcp.secretmanager.SecretIamMemberArgs;
import com.pulumi.gcp.integrationconnectors.Connection;
import com.pulumi.gcp.integrationconnectors.ConnectionArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionConfigVariableArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionConfigVariableEncryptionKeyValueArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionConfigVariableSecretValueArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionAuthConfigArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionAuthConfigUserPasswordArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionAuthConfigUserPasswordPasswordArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionDestinationConfigArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionLockConfigArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionLogConfigArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionNodeConfigArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionSslConfigArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionSslConfigClientCertificateArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionSslConfigClientPrivateKeyArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionSslConfigClientPrivateKeyPassArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionSslConfigPrivateServerCertificateArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionEventingConfigArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionEventingConfigRegistrationDestinationConfigArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionEventingConfigAuthConfigArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionEventingConfigAuthConfigUserPasswordArgs;
import com.pulumi.gcp.integrationconnectors.inputs.ConnectionEventingConfigAuthConfigUserPasswordPasswordArgs;
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 testProject = OrganizationsFunctions.getProject();
var secret_basic = new Secret("secret-basic", SecretArgs.builder()
.secretId("test-secret")
.replication(SecretReplicationArgs.builder()
.userManaged(SecretReplicationUserManagedArgs.builder()
.replicas(SecretReplicationUserManagedReplicaArgs.builder()
.location("us-central1")
.build())
.build())
.build())
.build());
var secret_version_basic = new SecretVersion("secret-version-basic", SecretVersionArgs.builder()
.secret(secret_basic.id())
.secretData("dummypassword")
.build());
var secretIam = new SecretIamMember("secretIam", SecretIamMemberArgs.builder()
.secretId(secret_basic.id())
.role("roles/secretmanager.admin")
.member(String.format("serviceAccount:%s-compute@developer.gserviceaccount.com", testProject.applyValue(getProjectResult -> getProjectResult.number())))
.build(), CustomResourceOptions.builder()
.dependsOn(secret_version_basic)
.build());
var zendeskconnection = new Connection("zendeskconnection", ConnectionArgs.builder()
.name("test-zendesk")
.description("tf updated description")
.location("us-central1")
.serviceAccount(String.format("%s-compute@developer.gserviceaccount.com", testProject.applyValue(getProjectResult -> getProjectResult.number())))
.connectorVersion(String.format("projects/%s/locations/global/providers/zendesk/connectors/zendesk/versions/1", testProject.applyValue(getProjectResult -> getProjectResult.projectId())))
.configVariables(
ConnectionConfigVariableArgs.builder()
.key("proxy_enabled")
.booleanValue(false)
.build(),
ConnectionConfigVariableArgs.builder()
.key("sample_integer_value")
.integerValue(1)
.build(),
ConnectionConfigVariableArgs.builder()
.key("sample_encryption_key_value")
.encryptionKeyValue(ConnectionConfigVariableEncryptionKeyValueArgs.builder()
.type("GOOGLE_MANAGED")
.kmsKeyName("sampleKMSKkey")
.build())
.build(),
ConnectionConfigVariableArgs.builder()
.key("sample_secret_value")
.secretValue(ConnectionConfigVariableSecretValueArgs.builder()
.secretVersion(secret_version_basic.name())
.build())
.build())
.suspended(false)
.authConfig(ConnectionAuthConfigArgs.builder()
.additionalVariables(
ConnectionAuthConfigAdditionalVariableArgs.builder()
.key("sample_string")
.stringValue("sampleString")
.build(),
ConnectionAuthConfigAdditionalVariableArgs.builder()
.key("sample_boolean")
.booleanValue(false)
.build(),
ConnectionAuthConfigAdditionalVariableArgs.builder()
.key("sample_integer")
.integerValue(1)
.build(),
ConnectionAuthConfigAdditionalVariableArgs.builder()
.key("sample_secret_value")
.secretValue(ConnectionAuthConfigAdditionalVariableSecretValueArgs.builder()
.secretVersion(secret_version_basic.name())
.build())
.build(),
ConnectionAuthConfigAdditionalVariableArgs.builder()
.key("sample_encryption_key_value")
.encryptionKeyValue(ConnectionAuthConfigAdditionalVariableEncryptionKeyValueArgs.builder()
.type("GOOGLE_MANAGED")
.kmsKeyName("sampleKMSKkey")
.build())
.build())
.authType("USER_PASSWORD")
.authKey("sampleAuthKey")
.userPassword(ConnectionAuthConfigUserPasswordArgs.builder()
.username("user@xyz.com")
.password(ConnectionAuthConfigUserPasswordPasswordArgs.builder()
.secretVersion(secret_version_basic.name())
.build())
.build())
.build())
.destinationConfigs(ConnectionDestinationConfigArgs.builder()
.key("url")
.destinations(ConnectionDestinationConfigDestinationArgs.builder()
.host("https://test.zendesk.com")
.port(80)
.build())
.build())
.lockConfig(ConnectionLockConfigArgs.builder()
.locked(false)
.reason("Its not locked")
.build())
.logConfig(ConnectionLogConfigArgs.builder()
.enabled(true)
.build())
.nodeConfig(ConnectionNodeConfigArgs.builder()
.minNodeCount(2)
.maxNodeCount(50)
.build())
.labels(Map.of("foo", "bar"))
.sslConfig(ConnectionSslConfigArgs.builder()
.additionalVariables(
ConnectionSslConfigAdditionalVariableArgs.builder()
.key("sample_string")
.stringValue("sampleString")
.build(),
ConnectionSslConfigAdditionalVariableArgs.builder()
.key("sample_boolean")
.booleanValue(false)
.build(),
ConnectionSslConfigAdditionalVariableArgs.builder()
.key("sample_integer")
.integerValue(1)
.build(),
ConnectionSslConfigAdditionalVariableArgs.builder()
.key("sample_secret_value")
.secretValue(ConnectionSslConfigAdditionalVariableSecretValueArgs.builder()
.secretVersion(secret_version_basic.name())
.build())
.build(),
ConnectionSslConfigAdditionalVariableArgs.builder()
.key("sample_encryption_key_value")
.encryptionKeyValue(ConnectionSslConfigAdditionalVariableEncryptionKeyValueArgs.builder()
.type("GOOGLE_MANAGED")
.kmsKeyName("sampleKMSKkey")
.build())
.build())
.clientCertType("PEM")
.clientCertificate(ConnectionSslConfigClientCertificateArgs.builder()
.secretVersion(secret_version_basic.name())
.build())
.clientPrivateKey(ConnectionSslConfigClientPrivateKeyArgs.builder()
.secretVersion(secret_version_basic.name())
.build())
.clientPrivateKeyPass(ConnectionSslConfigClientPrivateKeyPassArgs.builder()
.secretVersion(secret_version_basic.name())
.build())
.privateServerCertificate(ConnectionSslConfigPrivateServerCertificateArgs.builder()
.secretVersion(secret_version_basic.name())
.build())
.serverCertType("PEM")
.trustModel("PRIVATE")
.type("TLS")
.useSsl(true)
.build())
.eventingEnablementType("EVENTING_AND_CONNECTION")
.eventingConfig(ConnectionEventingConfigArgs.builder()
.additionalVariables(
ConnectionEventingConfigAdditionalVariableArgs.builder()
.key("sample_string")
.stringValue("sampleString")
.build(),
ConnectionEventingConfigAdditionalVariableArgs.builder()
.key("sample_boolean")
.booleanValue(false)
.build(),
ConnectionEventingConfigAdditionalVariableArgs.builder()
.key("sample_integer")
.integerValue(1)
.build(),
ConnectionEventingConfigAdditionalVariableArgs.builder()
.key("sample_secret_value")
.secretValue(ConnectionEventingConfigAdditionalVariableSecretValueArgs.builder()
.secretVersion(secret_version_basic.name())
.build())
.build(),
ConnectionEventingConfigAdditionalVariableArgs.builder()
.key("sample_encryption_key_value")
.encryptionKeyValue(ConnectionEventingConfigAdditionalVariableEncryptionKeyValueArgs.builder()
.type("GOOGLE_MANAGED")
.kmsKeyName("sampleKMSKkey")
.build())
.build())
.registrationDestinationConfig(ConnectionEventingConfigRegistrationDestinationConfigArgs.builder()
.key("registration_destination_config")
.destinations(ConnectionEventingConfigRegistrationDestinationConfigDestinationArgs.builder()
.host("https://test.zendesk.com")
.port(80)
.build())
.build())
.authConfig(ConnectionEventingConfigAuthConfigArgs.builder()
.authType("USER_PASSWORD")
.authKey("sampleAuthKey")
.userPassword(ConnectionEventingConfigAuthConfigUserPasswordArgs.builder()
.username("user@xyz.com")
.password(ConnectionEventingConfigAuthConfigUserPasswordPasswordArgs.builder()
.secretVersion(secret_version_basic.name())
.build())
.build())
.additionalVariables(
ConnectionEventingConfigAuthConfigAdditionalVariableArgs.builder()
.key("sample_string")
.stringValue("sampleString")
.build(),
ConnectionEventingConfigAuthConfigAdditionalVariableArgs.builder()
.key("sample_boolean")
.booleanValue(false)
.build(),
ConnectionEventingConfigAuthConfigAdditionalVariableArgs.builder()
.key("sample_integer")
.integerValue(1)
.build(),
ConnectionEventingConfigAuthConfigAdditionalVariableArgs.builder()
.key("sample_secret_value")
.secretValue(ConnectionEventingConfigAuthConfigAdditionalVariableSecretValueArgs.builder()
.secretVersion(secret_version_basic.name())
.build())
.build(),
ConnectionEventingConfigAuthConfigAdditionalVariableArgs.builder()
.key("sample_encryption_key_value")
.encryptionKeyValue(ConnectionEventingConfigAuthConfigAdditionalVariableEncryptionKeyValueArgs.builder()
.type("GOOGLE_MANAGED")
.kmsKeyName("sampleKMSKkey")
.build())
.build())
.build())
.enrichmentEnabled(true)
.build())
.build());
}
}Content copied to clipboard
resources:
secret-basic:
type: gcp:secretmanager:Secret
properties:
secretId: test-secret
replication:
userManaged:
replicas:
- location: us-central1
secret-version-basic:
type: gcp:secretmanager:SecretVersion
properties:
secret: ${["secret-basic"].id}
secretData: dummypassword
secretIam:
type: gcp:secretmanager:SecretIamMember
name: secret_iam
properties:
secretId: ${["secret-basic"].id}
role: roles/secretmanager.admin
member: serviceAccount:${testProject.number}-compute@developer.gserviceaccount.com
options:
dependson:
- ${["secret-version-basic"]}
zendeskconnection:
type: gcp:integrationconnectors:Connection
properties:
name: test-zendesk
description: tf updated description
location: us-central1
serviceAccount: ${testProject.number}-compute@developer.gserviceaccount.com
connectorVersion: projects/${testProject.projectId}/locations/global/providers/zendesk/connectors/zendesk/versions/1
configVariables:
- key: proxy_enabled
booleanValue: false
- key: sample_integer_value
integerValue: 1
- key: sample_encryption_key_value
encryptionKeyValue:
type: GOOGLE_MANAGED
kmsKeyName: sampleKMSKkey
- key: sample_secret_value
secretValue:
secretVersion: ${["secret-version-basic"].name}
suspended: false
authConfig:
additionalVariables:
- key: sample_string
stringValue: sampleString
- key: sample_boolean
booleanValue: false
- key: sample_integer
integerValue: 1
- key: sample_secret_value
secretValue:
secretVersion: ${["secret-version-basic"].name}
- key: sample_encryption_key_value
encryptionKeyValue:
type: GOOGLE_MANAGED
kmsKeyName: sampleKMSKkey
authType: USER_PASSWORD
authKey: sampleAuthKey
userPassword:
username: user@xyz.com
password:
secretVersion: ${["secret-version-basic"].name}
destinationConfigs:
- key: url
destinations:
- host: https://test.zendesk.com
port: 80
lockConfig:
locked: false
reason: Its not locked
logConfig:
enabled: true
nodeConfig:
minNodeCount: 2
maxNodeCount: 50
labels:
foo: bar
sslConfig:
additionalVariables:
- key: sample_string
stringValue: sampleString
- key: sample_boolean
booleanValue: false
- key: sample_integer
integerValue: 1
- key: sample_secret_value
secretValue:
secretVersion: ${["secret-version-basic"].name}
- key: sample_encryption_key_value
encryptionKeyValue:
type: GOOGLE_MANAGED
kmsKeyName: sampleKMSKkey
clientCertType: PEM
clientCertificate:
secretVersion: ${["secret-version-basic"].name}
clientPrivateKey:
secretVersion: ${["secret-version-basic"].name}
clientPrivateKeyPass:
secretVersion: ${["secret-version-basic"].name}
privateServerCertificate:
secretVersion: ${["secret-version-basic"].name}
serverCertType: PEM
trustModel: PRIVATE
type: TLS
useSsl: true
eventingEnablementType: EVENTING_AND_CONNECTION
eventingConfig:
additionalVariables:
- key: sample_string
stringValue: sampleString
- key: sample_boolean
booleanValue: false
- key: sample_integer
integerValue: 1
- key: sample_secret_value
secretValue:
secretVersion: ${["secret-version-basic"].name}
- key: sample_encryption_key_value
encryptionKeyValue:
type: GOOGLE_MANAGED
kmsKeyName: sampleKMSKkey
registrationDestinationConfig:
key: registration_destination_config
destinations:
- host: https://test.zendesk.com
port: 80
authConfig:
authType: USER_PASSWORD
authKey: sampleAuthKey
userPassword:
username: user@xyz.com
password:
secretVersion: ${["secret-version-basic"].name}
additionalVariables:
- key: sample_string
stringValue: sampleString
- key: sample_boolean
booleanValue: false
- key: sample_integer
integerValue: 1
- key: sample_secret_value
secretValue:
secretVersion: ${["secret-version-basic"].name}
- key: sample_encryption_key_value
encryptionKeyValue:
type: GOOGLE_MANAGED
kmsKeyName: sampleKMSKkey
enrichmentEnabled: true
variables:
testProject:
fn::invoke:
Function: gcp:organizations:getProject
Arguments: {}Content copied to clipboard
Import
Connection can be imported using any of these accepted formats:
projects/{{project}}/locations/{{location}}/connections/{{name}}{{project}}/{{location}}/{{name}}{{location}}/{{name}}When using thepulumi importcommand, Connection can be imported using one of the formats above. For example:
$ pulumi import gcp:integrationconnectors/connection:Connection default projects/{{project}}/locations/{{location}}/connections/{{name}}Content copied to clipboard
$ pulumi import gcp:integrationconnectors/connection:Connection default {{project}}/{{location}}/{{name}}Content copied to clipboard
$ pulumi import gcp:integrationconnectors/connection:Connection default {{location}}/{{name}}Content copied to clipboard
Properties
Link copied to clipboard
authConfig for the connection. Structure is documented below.
Link copied to clipboard
Config Variables for the connection. Structure is documented below.
Link copied to clipboard
Connection revision. This field is only updated when the connection is created or updated by User.
Link copied to clipboard
connectorVersion of the Connector.
Link copied to clipboard
This configuration provides infra configs like rate limit threshold which need to be configurable for every connector version. Structure is documented below.
Link copied to clipboard
Flag to mark the version indicating the launch stage.
Link copied to clipboard
Time the Namespace was created in UTC.
Link copied to clipboard
An arbitrary description for the Conection.
Link copied to clipboard
Define the Connectors target endpoint. Structure is documented below.
Link copied to clipboard
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
Eventing Configuration of a connection Structure is documented below.
Link copied to clipboard
Eventing enablement type. Will be nil if eventing is not enabled. Possible values are: EVENTING_AND_CONNECTION, ONLY_EVENTING.
Link copied to clipboard
Eventing Runtime Data. Structure is documented below.
Link copied to clipboard
Link copied to clipboard
Determines whether or no a connection is locked. If locked, a reason must be specified. Structure is documented below.
Link copied to clipboard
Log configuration for the connection. Structure is documented below.
Link copied to clipboard
Node configuration for the connection. Structure is documented below.
Link copied to clipboard
Link copied to clipboard
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
Service account needed for runtime plane to access Google Cloud resources.
Link copied to clipboard
The name of the Service Directory service name. Used for Private Harpoon to resolve the ILB address. e.g. "projects/cloud-connectors-e2e-testing/locations/us-central1/namespaces/istio-system/services/istio-ingressgateway-connectors"
Link copied to clipboard
SSL Configuration of a connection Structure is documented below.
Link copied to clipboard
(Output) Current status of eventing. Structure is documented below.
Link copied to clipboard
This subscription type enum states the subscription type of the project.
Link copied to clipboard
Time the Namespace was updated in UTC.