gcp.sql.ProvisionScript

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

const instance = new gcp.sql.DatabaseInstance("instance", {
    name: "my-instance",
    databaseVersion: "POSTGRES_17",
    settings: {
        tier: "db-perf-optimized-N-2",
        dataApiAccess: "ALLOW_DATA_API",
        databaseFlags: [{
            name: "cloudsql.iam_authentication",
            value: "on",
        }],
    },
});
// Create a database user for your account and grant roles so it has privilege to access the database.
// Set the type to "CLOUD_IAM_USER" for huamn account or "CLOUD_IAM_SERVICE_ACCOUNT" for service account.
// If a service account is used and the instance is Postgres, please trim the ".gserviceaccount.com" suffix
// to avoid exceeding the username length limit.
const iamUser = new gcp.sql.User("iam_user", {
    name: "account-used-to-apply-this-config@example.com",
    instance: instance.name,
    type: "CLOUD_IAM_USER",
    databaseRoles: ["cloudsqlsuperuser"],
});
const database = new gcp.sql.Database("database", {
    name: "my-database",
    instance: instance.name,
});
const table = new gcp.sql.ProvisionScript("table", {
    script: "CREATE TABLE IF NOT EXISTS table1 ( col VARCHAR(16) NOT NULL );",
    instance: instance.name,
    database: database.name,
    description: "sql script to create tables",
}, {
    dependsOn: [iamUser],
});

import pulumi
import pulumi_gcp as gcp

instance = gcp.sql.DatabaseInstance("instance",
    name="my-instance",
    database_version="POSTGRES_17",
    settings={
        "tier": "db-perf-optimized-N-2",
        "data_api_access": "ALLOW_DATA_API",
        "database_flags": [{
            "name": "cloudsql.iam_authentication",
            "value": "on",
        }],
    })
# Create a database user for your account and grant roles so it has privilege to access the database.
# Set the type to "CLOUD_IAM_USER" for huamn account or "CLOUD_IAM_SERVICE_ACCOUNT" for service account.
# If a service account is used and the instance is Postgres, please trim the ".gserviceaccount.com" suffix
# to avoid exceeding the username length limit.
iam_user = gcp.sql.User("iam_user",
    name="account-used-to-apply-this-config@example.com",
    instance=instance.name,
    type="CLOUD_IAM_USER",
    database_roles=["cloudsqlsuperuser"])
database = gcp.sql.Database("database",
    name="my-database",
    instance=instance.name)
table = gcp.sql.ProvisionScript("table",
    script="CREATE TABLE IF NOT EXISTS table1 ( col VARCHAR(16) NOT NULL );",
    instance=instance.name,
    database=database.name,
    description="sql script to create tables",
    opts = pulumi.ResourceOptions(depends_on=[iam_user]))

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/sql"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		instance, err := sql.NewDatabaseInstance(ctx, "instance", &sql.DatabaseInstanceArgs{
			Name:            pulumi.String("my-instance"),
			DatabaseVersion: pulumi.String("POSTGRES_17"),
			Settings: &sql.DatabaseInstanceSettingsArgs{
				Tier:          pulumi.String("db-perf-optimized-N-2"),
				DataApiAccess: pulumi.String("ALLOW_DATA_API"),
				DatabaseFlags: sql.DatabaseInstanceSettingsDatabaseFlagArray{
					&sql.DatabaseInstanceSettingsDatabaseFlagArgs{
						Name:  pulumi.String("cloudsql.iam_authentication"),
						Value: pulumi.String("on"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// Create a database user for your account and grant roles so it has privilege to access the database.
		// Set the type to "CLOUD_IAM_USER" for huamn account or "CLOUD_IAM_SERVICE_ACCOUNT" for service account.
		// If a service account is used and the instance is Postgres, please trim the ".gserviceaccount.com" suffix
		// to avoid exceeding the username length limit.
		iamUser, err := sql.NewUser(ctx, "iam_user", &sql.UserArgs{
			Name:     pulumi.String("account-used-to-apply-this-config@example.com"),
			Instance: instance.Name,
			Type:     pulumi.String("CLOUD_IAM_USER"),
			DatabaseRoles: pulumi.StringArray{
				pulumi.String("cloudsqlsuperuser"),
			},
		})
		if err != nil {
			return err
		}
		database, err := sql.NewDatabase(ctx, "database", &sql.DatabaseArgs{
			Name:     pulumi.String("my-database"),
			Instance: instance.Name,
		})
		if err != nil {
			return err
		}
		_, err = sql.NewProvisionScript(ctx, "table", &sql.ProvisionScriptArgs{
			Script:      pulumi.String("CREATE TABLE IF NOT EXISTS table1 ( col VARCHAR(16) NOT NULL );"),
			Instance:    instance.Name,
			Database:    database.Name,
			Description: pulumi.String("sql script to create tables"),
		}, pulumi.DependsOn([]pulumi.Resource{
			iamUser,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var instance = new Gcp.Sql.DatabaseInstance("instance", new()
    {
        Name = "my-instance",
        DatabaseVersion = "POSTGRES_17",
        Settings = new Gcp.Sql.Inputs.DatabaseInstanceSettingsArgs
        {
            Tier = "db-perf-optimized-N-2",
            DataApiAccess = "ALLOW_DATA_API",
            DatabaseFlags = new[]
            {
                new Gcp.Sql.Inputs.DatabaseInstanceSettingsDatabaseFlagArgs
                {
                    Name = "cloudsql.iam_authentication",
                    Value = "on",
                },
            },
        },
    });

    // Create a database user for your account and grant roles so it has privilege to access the database.
    // Set the type to "CLOUD_IAM_USER" for huamn account or "CLOUD_IAM_SERVICE_ACCOUNT" for service account.
    // If a service account is used and the instance is Postgres, please trim the ".gserviceaccount.com" suffix
    // to avoid exceeding the username length limit.
    var iamUser = new Gcp.Sql.User("iam_user", new()
    {
        Name = "account-used-to-apply-this-config@example.com",
        Instance = instance.Name,
        Type = "CLOUD_IAM_USER",
        DatabaseRoles = new[]
        {
            "cloudsqlsuperuser",
        },
    });

    var database = new Gcp.Sql.Database("database", new()
    {
        Name = "my-database",
        Instance = instance.Name,
    });

    var table = new Gcp.Sql.ProvisionScript("table", new()
    {
        Script = "CREATE TABLE IF NOT EXISTS table1 ( col VARCHAR(16) NOT NULL );",
        Instance = instance.Name,
        Database = database.Name,
        Description = "sql script to create tables",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            iamUser,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.sql.DatabaseInstance;
import com.pulumi.gcp.sql.DatabaseInstanceArgs;
import com.pulumi.gcp.sql.inputs.DatabaseInstanceSettingsArgs;
import com.pulumi.gcp.sql.User;
import com.pulumi.gcp.sql.UserArgs;
import com.pulumi.gcp.sql.Database;
import com.pulumi.gcp.sql.DatabaseArgs;
import com.pulumi.gcp.sql.ProvisionScript;
import com.pulumi.gcp.sql.ProvisionScriptArgs;
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) {
        var instance = new DatabaseInstance("instance", DatabaseInstanceArgs.builder()
            .name("my-instance")
            .databaseVersion("POSTGRES_17")
            .settings(DatabaseInstanceSettingsArgs.builder()
                .tier("db-perf-optimized-N-2")
                .dataApiAccess("ALLOW_DATA_API")
                .databaseFlags(DatabaseInstanceSettingsDatabaseFlagArgs.builder()
                    .name("cloudsql.iam_authentication")
                    .value("on")
                    .build())
                .build())
            .build());

        // Create a database user for your account and grant roles so it has privilege to access the database.
        // Set the type to "CLOUD_IAM_USER" for huamn account or "CLOUD_IAM_SERVICE_ACCOUNT" for service account.
        // If a service account is used and the instance is Postgres, please trim the ".gserviceaccount.com" suffix
        // to avoid exceeding the username length limit.
        var iamUser = new User("iamUser", UserArgs.builder()
            .name("account-used-to-apply-this-config@example.com")
            .instance(instance.name())
            .type("CLOUD_IAM_USER")
            .databaseRoles("cloudsqlsuperuser")
            .build());

        var database = new Database("database", DatabaseArgs.builder()
            .name("my-database")
            .instance(instance.name())
            .build());

        var table = new ProvisionScript("table", ProvisionScriptArgs.builder()
            .script("CREATE TABLE IF NOT EXISTS table1 ( col VARCHAR(16) NOT NULL );")
            .instance(instance.name())
            .database(database.name())
            .description("sql script to create tables")
            .build(), CustomResourceOptions.builder()
                .dependsOn(iamUser)
                .build());

    }
}

resources:
  instance:
    type: gcp:sql:DatabaseInstance
    properties:
      name: my-instance
      databaseVersion: POSTGRES_17
      settings:
        tier: db-perf-optimized-N-2
        dataApiAccess: ALLOW_DATA_API
        databaseFlags:
          - name: cloudsql.iam_authentication
            value: on
  # Create a database user for your account and grant roles so it has privilege to access the database.
  # Set the type to "CLOUD_IAM_USER" for huamn account or "CLOUD_IAM_SERVICE_ACCOUNT" for service account.
  # If a service account is used and the instance is Postgres, please trim the ".gserviceaccount.com" suffix
  # to avoid exceeding the username length limit.
  iamUser:
    type: gcp:sql:User
    name: iam_user
    properties:
      name: account-used-to-apply-this-config@example.com
      instance: ${instance.name}
      type: CLOUD_IAM_USER
      databaseRoles: # Roles granted to the user. Smaller roles are preferred, if exist.
        - cloudsqlsuperuser
  database:
    type: gcp:sql:Database
    properties:
      name: my-database
      instance: ${instance.name}
  table:
    type: gcp:sql:ProvisionScript
    properties:
      script: CREATE TABLE IF NOT EXISTS table1 ( col VARCHAR(16) NOT NULL );
      instance: ${instance.name}
      database: ${database.name}
      description: sql script to create tables
    options:
      dependsOn:
        - ${iamUser}

var provisionScriptResource = new Gcp.Sql.ProvisionScript("provisionScriptResource", new()
{
    Instance = "string",
    Script = "string",
    Database = "string",
    DeletionPolicy = "string",
    Description = "string",
    Project = "string",
});

example, err := sql.NewProvisionScript(ctx, "provisionScriptResource", &sql.ProvisionScriptArgs{
	Instance:       pulumi.String("string"),
	Script:         pulumi.String("string"),
	Database:       pulumi.String("string"),
	DeletionPolicy: pulumi.String("string"),
	Description:    pulumi.String("string"),
	Project:        pulumi.String("string"),
})

var provisionScriptResource = new ProvisionScript("provisionScriptResource", ProvisionScriptArgs.builder()
    .instance("string")
    .script("string")
    .database("string")
    .deletionPolicy("string")
    .description("string")
    .project("string")
    .build());

provision_script_resource = gcp.sql.ProvisionScript("provisionScriptResource",
    instance="string",
    script="string",
    database="string",
    deletion_policy="string",
    description="string",
    project="string")

const provisionScriptResource = new gcp.sql.ProvisionScript("provisionScriptResource", {
    instance: "string",
    script: "string",
    database: "string",
    deletionPolicy: "string",
    description: "string",
    project: "string",
});

type: gcp:sql:ProvisionScript
properties:
    database: string
    deletionPolicy: string
    description: string
    instance: string
    project: string
    script: string