com.pulumi.gcp.composer.kotlin.ComposerFunctions.kt Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of pulumi-gcp-kotlin Show documentation
Show all versions of pulumi-gcp-kotlin Show documentation
Build cloud applications and infrastructure by combining the safety and reliability of infrastructure as code with the power of the Kotlin programming language.
@file:Suppress("NAME_SHADOWING", "DEPRECATION")
package com.pulumi.gcp.composer.kotlin
import com.pulumi.gcp.composer.ComposerFunctions.getEnvironmentPlain
import com.pulumi.gcp.composer.ComposerFunctions.getImageVersionsPlain
import com.pulumi.gcp.composer.ComposerFunctions.getUserWorkloadsConfigMapPlain
import com.pulumi.gcp.composer.ComposerFunctions.getUserWorkloadsSecretPlain
import com.pulumi.gcp.composer.kotlin.inputs.GetEnvironmentPlainArgs
import com.pulumi.gcp.composer.kotlin.inputs.GetEnvironmentPlainArgsBuilder
import com.pulumi.gcp.composer.kotlin.inputs.GetImageVersionsPlainArgs
import com.pulumi.gcp.composer.kotlin.inputs.GetImageVersionsPlainArgsBuilder
import com.pulumi.gcp.composer.kotlin.inputs.GetUserWorkloadsConfigMapPlainArgs
import com.pulumi.gcp.composer.kotlin.inputs.GetUserWorkloadsConfigMapPlainArgsBuilder
import com.pulumi.gcp.composer.kotlin.inputs.GetUserWorkloadsSecretPlainArgs
import com.pulumi.gcp.composer.kotlin.inputs.GetUserWorkloadsSecretPlainArgsBuilder
import com.pulumi.gcp.composer.kotlin.outputs.GetEnvironmentResult
import com.pulumi.gcp.composer.kotlin.outputs.GetImageVersionsResult
import com.pulumi.gcp.composer.kotlin.outputs.GetUserWorkloadsConfigMapResult
import com.pulumi.gcp.composer.kotlin.outputs.GetUserWorkloadsSecretResult
import kotlinx.coroutines.future.await
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import com.pulumi.gcp.composer.kotlin.outputs.GetEnvironmentResult.Companion.toKotlin as getEnvironmentResultToKotlin
import com.pulumi.gcp.composer.kotlin.outputs.GetImageVersionsResult.Companion.toKotlin as getImageVersionsResultToKotlin
import com.pulumi.gcp.composer.kotlin.outputs.GetUserWorkloadsConfigMapResult.Companion.toKotlin as getUserWorkloadsConfigMapResultToKotlin
import com.pulumi.gcp.composer.kotlin.outputs.GetUserWorkloadsSecretResult.Companion.toKotlin as getUserWorkloadsSecretResultToKotlin
public object ComposerFunctions {
/**
* Provides access to Cloud Composer environment configuration in a region for a given project.
* ## Example Usage
*
* ```typescript
* import * as pulumi from "@pulumi/pulumi";
* import * as gcp from "@pulumi/gcp";
* const composerEnvEnvironment = new gcp.composer.Environment("composer_env", {name: "composer-environment"});
* const composerEnv = gcp.composer.getEnvironment({
* name: test.name,
* });
* export const debug = composerEnv.then(composerEnv => composerEnv.configs);
* ```
* ```python
* import pulumi
* import pulumi_gcp as gcp
* composer_env_environment = gcp.composer.Environment("composer_env", name="composer-environment")
* composer_env = gcp.composer.get_environment(name=test["name"])
* pulumi.export("debug", composer_env.configs)
* ```
* ```csharp
* using System.Collections.Generic;
* using System.Linq;
* using Pulumi;
* using Gcp = Pulumi.Gcp;
* return await Deployment.RunAsync(() =>
* {
* var composerEnvEnvironment = new Gcp.Composer.Environment("composer_env", new()
* {
* Name = "composer-environment",
* });
* var composerEnv = Gcp.Composer.GetEnvironment.Invoke(new()
* {
* Name = test.Name,
* });
* return new Dictionary
* {
* ["debug"] = composerEnv.Apply(getEnvironmentResult => getEnvironmentResult.Configs),
* };
* });
* ```
* ```go
* package main
* import (
* "github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/composer"
* "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
* )
* func main() {
* pulumi.Run(func(ctx *pulumi.Context) error {
* _, err := composer.NewEnvironment(ctx, "composer_env", &composer.EnvironmentArgs{
* Name: pulumi.String("composer-environment"),
* })
* if err != nil {
* return err
* }
* composerEnv, err := composer.LookupEnvironment(ctx, &composer.LookupEnvironmentArgs{
* Name: test.Name,
* }, nil)
* if err != nil {
* return err
* }
* ctx.Export("debug", composerEnv.Configs)
* return nil
* })
* }
* ```
* ```java
* package generated_program;
* import com.pulumi.Context;
* import com.pulumi.Pulumi;
* import com.pulumi.core.Output;
* import com.pulumi.gcp.composer.Environment;
* import com.pulumi.gcp.composer.EnvironmentArgs;
* import com.pulumi.gcp.composer.ComposerFunctions;
* import com.pulumi.gcp.composer.inputs.GetEnvironmentArgs;
* 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 composerEnvEnvironment = new Environment("composerEnvEnvironment", EnvironmentArgs.builder()
* .name("composer-environment")
* .build());
* final var composerEnv = ComposerFunctions.getEnvironment(GetEnvironmentArgs.builder()
* .name(test.name())
* .build());
* ctx.export("debug", composerEnv.applyValue(getEnvironmentResult -> getEnvironmentResult.configs()));
* }
* }
* ```
* ```yaml
* resources:
* composerEnvEnvironment:
* type: gcp:composer:Environment
* name: composer_env
* properties:
* name: composer-environment
* variables:
* composerEnv:
* fn::invoke:
* Function: gcp:composer:getEnvironment
* Arguments:
* name: ${test.name}
* outputs:
* debug: ${composerEnv.configs}
* ```
*
* @param argument A collection of arguments for invoking getEnvironment.
* @return A collection of values returned by getEnvironment.
*/
public suspend fun getEnvironment(argument: GetEnvironmentPlainArgs): GetEnvironmentResult =
getEnvironmentResultToKotlin(getEnvironmentPlain(argument.toJava()).await())
/**
* @see [getEnvironment].
* @param name Name of the environment.
* @param project The ID of the project in which the resource belongs.
* If it is not provided, the provider project is used.
* @param region The location or Compute Engine region of the environment.
* @return A collection of values returned by getEnvironment.
*/
public suspend fun getEnvironment(
name: String,
project: String? = null,
region: String? = null,
): GetEnvironmentResult {
val argument = GetEnvironmentPlainArgs(
name = name,
project = project,
region = region,
)
return getEnvironmentResultToKotlin(getEnvironmentPlain(argument.toJava()).await())
}
/**
* @see [getEnvironment].
* @param argument Builder for [com.pulumi.gcp.composer.kotlin.inputs.GetEnvironmentPlainArgs].
* @return A collection of values returned by getEnvironment.
*/
public suspend fun getEnvironment(argument: suspend GetEnvironmentPlainArgsBuilder.() -> Unit): GetEnvironmentResult {
val builder = GetEnvironmentPlainArgsBuilder()
builder.argument()
val builtArgument = builder.build()
return getEnvironmentResultToKotlin(getEnvironmentPlain(builtArgument.toJava()).await())
}
/**
* Provides access to available Cloud Composer versions in a region for a given project.
* ## Example Usage
*
* ```typescript
* import * as pulumi from "@pulumi/pulumi";
* import * as gcp from "@pulumi/gcp";
* const all = gcp.composer.getImageVersions({});
* const test = new gcp.composer.Environment("test", {
* name: "test-env",
* region: "us-central1",
* config: {
* softwareConfig: {
* imageVersion: all.then(all => all.imageVersions?.[0]?.imageVersionId),
* },
* },
* });
* ```
* ```python
* import pulumi
* import pulumi_gcp as gcp
* all = gcp.composer.get_image_versions()
* test = gcp.composer.Environment("test",
* name="test-env",
* region="us-central1",
* config={
* "software_config": {
* "image_version": all.image_versions[0].image_version_id,
* },
* })
* ```
* ```csharp
* using System.Collections.Generic;
* using System.Linq;
* using Pulumi;
* using Gcp = Pulumi.Gcp;
* return await Deployment.RunAsync(() =>
* {
* var all = Gcp.Composer.GetImageVersions.Invoke();
* var test = new Gcp.Composer.Environment("test", new()
* {
* Name = "test-env",
* Region = "us-central1",
* Config = new Gcp.Composer.Inputs.EnvironmentConfigArgs
* {
* SoftwareConfig = new Gcp.Composer.Inputs.EnvironmentConfigSoftwareConfigArgs
* {
* ImageVersion = all.Apply(getImageVersionsResult => getImageVersionsResult.ImageVersions[0]?.ImageVersionId),
* },
* },
* });
* });
* ```
* ```go
* package main
* import (
* "github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/composer"
* "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
* )
* func main() {
* pulumi.Run(func(ctx *pulumi.Context) error {
* all, err := composer.GetImageVersions(ctx, nil, nil)
* if err != nil {
* return err
* }
* _, err = composer.NewEnvironment(ctx, "test", &composer.EnvironmentArgs{
* Name: pulumi.String("test-env"),
* Region: pulumi.String("us-central1"),
* Config: &composer.EnvironmentConfigArgs{
* SoftwareConfig: &composer.EnvironmentConfigSoftwareConfigArgs{
* ImageVersion: pulumi.String(all.ImageVersions[0].ImageVersionId),
* },
* },
* })
* if err != nil {
* return err
* }
* return nil
* })
* }
* ```
* ```java
* package generated_program;
* import com.pulumi.Context;
* import com.pulumi.Pulumi;
* import com.pulumi.core.Output;
* import com.pulumi.gcp.composer.ComposerFunctions;
* import com.pulumi.gcp.composer.inputs.GetImageVersionsArgs;
* import com.pulumi.gcp.composer.Environment;
* import com.pulumi.gcp.composer.EnvironmentArgs;
* import com.pulumi.gcp.composer.inputs.EnvironmentConfigArgs;
* import com.pulumi.gcp.composer.inputs.EnvironmentConfigSoftwareConfigArgs;
* 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 all = ComposerFunctions.getImageVersions();
* var test = new Environment("test", EnvironmentArgs.builder()
* .name("test-env")
* .region("us-central1")
* .config(EnvironmentConfigArgs.builder()
* .softwareConfig(EnvironmentConfigSoftwareConfigArgs.builder()
* .imageVersion(all.applyValue(getImageVersionsResult -> getImageVersionsResult.imageVersions()[0].imageVersionId()))
* .build())
* .build())
* .build());
* }
* }
* ```
* ```yaml
* resources:
* test:
* type: gcp:composer:Environment
* properties:
* name: test-env
* region: us-central1
* config:
* softwareConfig:
* imageVersion: ${all.imageVersions[0].imageVersionId}
* variables:
* all:
* fn::invoke:
* Function: gcp:composer:getImageVersions
* Arguments: {}
* ```
*
* @param argument A collection of arguments for invoking getImageVersions.
* @return A collection of values returned by getImageVersions.
*/
public suspend fun getImageVersions(argument: GetImageVersionsPlainArgs): GetImageVersionsResult =
getImageVersionsResultToKotlin(getImageVersionsPlain(argument.toJava()).await())
/**
* @see [getImageVersions].
* @param project The ID of the project to list versions in.
* If it is not provided, the provider project is used.
* @param region The location to list versions in.
* If it is not provider, the provider region is used.
* @return A collection of values returned by getImageVersions.
*/
public suspend fun getImageVersions(project: String? = null, region: String? = null): GetImageVersionsResult {
val argument = GetImageVersionsPlainArgs(
project = project,
region = region,
)
return getImageVersionsResultToKotlin(getImageVersionsPlain(argument.toJava()).await())
}
/**
* @see [getImageVersions].
* @param argument Builder for [com.pulumi.gcp.composer.kotlin.inputs.GetImageVersionsPlainArgs].
* @return A collection of values returned by getImageVersions.
*/
public suspend fun getImageVersions(argument: suspend GetImageVersionsPlainArgsBuilder.() -> Unit): GetImageVersionsResult {
val builder = GetImageVersionsPlainArgsBuilder()
builder.argument()
val builtArgument = builder.build()
return getImageVersionsResultToKotlin(getImageVersionsPlain(builtArgument.toJava()).await())
}
/**
* ## Example Usage
*
* ```typescript
* import * as pulumi from "@pulumi/pulumi";
* import * as gcp from "@pulumi/gcp";
* const exampleEnvironment = new gcp.composer.Environment("example", {
* name: "example-environment",
* config: {
* softwareConfig: {
* imageVersion: "composer-3-airflow-2",
* },
* },
* });
* const exampleUserWorkloadsConfigMap = new gcp.composer.UserWorkloadsConfigMap("example", {
* environment: exampleEnvironment.name,
* name: "example-config-map",
* data: {
* db_host: "dbhost:5432",
* api_host: "apihost:443",
* },
* });
* const example = exampleEnvironment.name.apply(name => gcp.composer.getUserWorkloadsConfigMapOutput({
* environment: name,
* name: googleComposerUserWorkloadsConfigMap.example.name,
* }));
* export const debug = example;
* ```
* ```python
* import pulumi
* import pulumi_gcp as gcp
* example_environment = gcp.composer.Environment("example",
* name="example-environment",
* config={
* "software_config": {
* "image_version": "composer-3-airflow-2",
* },
* })
* example_user_workloads_config_map = gcp.composer.UserWorkloadsConfigMap("example",
* environment=example_environment.name,
* name="example-config-map",
* data={
* "db_host": "dbhost:5432",
* "api_host": "apihost:443",
* })
* example = example_environment.name.apply(lambda name: gcp.composer.get_user_workloads_config_map_output(environment=name,
* name=google_composer_user_workloads_config_map["example"]["name"]))
* pulumi.export("debug", example)
* ```
* ```csharp
* using System.Collections.Generic;
* using System.Linq;
* using Pulumi;
* using Gcp = Pulumi.Gcp;
* return await Deployment.RunAsync(() =>
* {
* var exampleEnvironment = new Gcp.Composer.Environment("example", new()
* {
* Name = "example-environment",
* Config = new Gcp.Composer.Inputs.EnvironmentConfigArgs
* {
* SoftwareConfig = new Gcp.Composer.Inputs.EnvironmentConfigSoftwareConfigArgs
* {
* ImageVersion = "composer-3-airflow-2",
* },
* },
* });
* var exampleUserWorkloadsConfigMap = new Gcp.Composer.UserWorkloadsConfigMap("example", new()
* {
* Environment = exampleEnvironment.Name,
* Name = "example-config-map",
* Data =
* {
* { "db_host", "dbhost:5432" },
* { "api_host", "apihost:443" },
* },
* });
* var example = Gcp.Composer.GetUserWorkloadsConfigMap.Invoke(new()
* {
* Environment = exampleEnvironment.Name,
* Name = googleComposerUserWorkloadsConfigMap.Example.Name,
* });
* return new Dictionary
* {
* ["debug"] = example,
* };
* });
* ```
* ```go
* package main
* import (
* "github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/composer"
* "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
* )
* func main() {
* pulumi.Run(func(ctx *pulumi.Context) error {
* exampleEnvironment, err := composer.NewEnvironment(ctx, "example", &composer.EnvironmentArgs{
* Name: pulumi.String("example-environment"),
* Config: &composer.EnvironmentConfigArgs{
* SoftwareConfig: &composer.EnvironmentConfigSoftwareConfigArgs{
* ImageVersion: pulumi.String("composer-3-airflow-2"),
* },
* },
* })
* if err != nil {
* return err
* }
* _, err = composer.NewUserWorkloadsConfigMap(ctx, "example", &composer.UserWorkloadsConfigMapArgs{
* Environment: exampleEnvironment.Name,
* Name: pulumi.String("example-config-map"),
* Data: pulumi.StringMap{
* "db_host": pulumi.String("dbhost:5432"),
* "api_host": pulumi.String("apihost:443"),
* },
* })
* if err != nil {
* return err
* }
* example := exampleEnvironment.Name.ApplyT(func(name string) (composer.GetUserWorkloadsConfigMapResult, error) {
* return composer.GetUserWorkloadsConfigMapResult(interface{}(composer.LookupUserWorkloadsConfigMapOutput(ctx, composer.GetUserWorkloadsConfigMapOutputArgs{
* Environment: name,
* Name: googleComposerUserWorkloadsConfigMap.Example.Name,
* }, nil))), nil
* }).(composer.GetUserWorkloadsConfigMapResultOutput)
* ctx.Export("debug", example)
* return nil
* })
* }
* ```
* ```java
* package generated_program;
* import com.pulumi.Context;
* import com.pulumi.Pulumi;
* import com.pulumi.core.Output;
* import com.pulumi.gcp.composer.Environment;
* import com.pulumi.gcp.composer.EnvironmentArgs;
* import com.pulumi.gcp.composer.inputs.EnvironmentConfigArgs;
* import com.pulumi.gcp.composer.inputs.EnvironmentConfigSoftwareConfigArgs;
* import com.pulumi.gcp.composer.UserWorkloadsConfigMap;
* import com.pulumi.gcp.composer.UserWorkloadsConfigMapArgs;
* import com.pulumi.gcp.composer.ComposerFunctions;
* import com.pulumi.gcp.composer.inputs.GetUserWorkloadsConfigMapArgs;
* 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 exampleEnvironment = new Environment("exampleEnvironment", EnvironmentArgs.builder()
* .name("example-environment")
* .config(EnvironmentConfigArgs.builder()
* .softwareConfig(EnvironmentConfigSoftwareConfigArgs.builder()
* .imageVersion("composer-3-airflow-2")
* .build())
* .build())
* .build());
* var exampleUserWorkloadsConfigMap = new UserWorkloadsConfigMap("exampleUserWorkloadsConfigMap", UserWorkloadsConfigMapArgs.builder()
* .environment(exampleEnvironment.name())
* .name("example-config-map")
* .data(Map.ofEntries(
* Map.entry("db_host", "dbhost:5432"),
* Map.entry("api_host", "apihost:443")
* ))
* .build());
* final var example = ComposerFunctions.getUserWorkloadsConfigMap(GetUserWorkloadsConfigMapArgs.builder()
* .environment(exampleEnvironment.name())
* .name(googleComposerUserWorkloadsConfigMap.example().name())
* .build());
* ctx.export("debug", example.applyValue(getUserWorkloadsConfigMapResult -> getUserWorkloadsConfigMapResult));
* }
* }
* ```
* ```yaml
* resources:
* exampleEnvironment:
* type: gcp:composer:Environment
* name: example
* properties:
* name: example-environment
* config:
* softwareConfig:
* imageVersion: composer-3-airflow-2
* exampleUserWorkloadsConfigMap:
* type: gcp:composer:UserWorkloadsConfigMap
* name: example
* properties:
* environment: ${exampleEnvironment.name}
* name: example-config-map
* data:
* db_host: dbhost:5432
* api_host: apihost:443
* variables:
* example:
* fn::invoke:
* Function: gcp:composer:getUserWorkloadsConfigMap
* Arguments:
* environment: ${exampleEnvironment.name}
* name: ${googleComposerUserWorkloadsConfigMap.example.name}
* outputs:
* debug: ${example}
* ```
*
* @param argument A collection of arguments for invoking getUserWorkloadsConfigMap.
* @return A collection of values returned by getUserWorkloadsConfigMap.
*/
public suspend fun getUserWorkloadsConfigMap(argument: GetUserWorkloadsConfigMapPlainArgs): GetUserWorkloadsConfigMapResult =
getUserWorkloadsConfigMapResultToKotlin(getUserWorkloadsConfigMapPlain(argument.toJava()).await())
/**
* @see [getUserWorkloadsConfigMap].
* @param environment Environment where the ConfigMap is stored.
* @param name Name of the ConfigMap.
* @param project The ID of the project in which the resource belongs.
* If it is not provided, the provider project is used.
* @param region The location or Compute Engine region of the environment.
* @return A collection of values returned by getUserWorkloadsConfigMap.
*/
public suspend fun getUserWorkloadsConfigMap(
environment: String,
name: String,
project: String? = null,
region: String? = null,
): GetUserWorkloadsConfigMapResult {
val argument = GetUserWorkloadsConfigMapPlainArgs(
environment = environment,
name = name,
project = project,
region = region,
)
return getUserWorkloadsConfigMapResultToKotlin(getUserWorkloadsConfigMapPlain(argument.toJava()).await())
}
/**
* @see [getUserWorkloadsConfigMap].
* @param argument Builder for [com.pulumi.gcp.composer.kotlin.inputs.GetUserWorkloadsConfigMapPlainArgs].
* @return A collection of values returned by getUserWorkloadsConfigMap.
*/
public suspend fun getUserWorkloadsConfigMap(argument: suspend GetUserWorkloadsConfigMapPlainArgsBuilder.() -> Unit): GetUserWorkloadsConfigMapResult {
val builder = GetUserWorkloadsConfigMapPlainArgsBuilder()
builder.argument()
val builtArgument = builder.build()
return getUserWorkloadsConfigMapResultToKotlin(getUserWorkloadsConfigMapPlain(builtArgument.toJava()).await())
}
/**
* ## Example Usage
*
* ```typescript
* import * as pulumi from "@pulumi/pulumi";
* import * as gcp from "@pulumi/gcp";
* import * as std from "@pulumi/std";
* const exampleEnvironment = new gcp.composer.Environment("example", {
* name: "example-environment",
* config: {
* softwareConfig: {
* imageVersion: "composer-3-airflow-2",
* },
* },
* });
* const exampleUserWorkloadsSecret = new gcp.composer.UserWorkloadsSecret("example", {
* environment: exampleEnvironment.name,
* name: "example-secret",
* data: {
* username: std.base64encode({
* input: "username",
* }).then(invoke => invoke.result),
* password: std.base64encode({
* input: "password",
* }).then(invoke => invoke.result),
* },
* });
* const example = exampleEnvironment.name.apply(name => gcp.composer.getUserWorkloadsSecretOutput({
* environment: name,
* name: googleComposerUserWorkloadsSecret.example.name,
* }));
* export const debug = example;
* ```
* ```python
* import pulumi
* import pulumi_gcp as gcp
* import pulumi_std as std
* example_environment = gcp.composer.Environment("example",
* name="example-environment",
* config={
* "software_config": {
* "image_version": "composer-3-airflow-2",
* },
* })
* example_user_workloads_secret = gcp.composer.UserWorkloadsSecret("example",
* environment=example_environment.name,
* name="example-secret",
* data={
* "username": std.base64encode(input="username").result,
* "password": std.base64encode(input="password").result,
* })
* example = example_environment.name.apply(lambda name: gcp.composer.get_user_workloads_secret_output(environment=name,
* name=google_composer_user_workloads_secret["example"]["name"]))
* pulumi.export("debug", example)
* ```
* ```csharp
* using System.Collections.Generic;
* using System.Linq;
* using Pulumi;
* using Gcp = Pulumi.Gcp;
* using Std = Pulumi.Std;
* return await Deployment.RunAsync(() =>
* {
* var exampleEnvironment = new Gcp.Composer.Environment("example", new()
* {
* Name = "example-environment",
* Config = new Gcp.Composer.Inputs.EnvironmentConfigArgs
* {
* SoftwareConfig = new Gcp.Composer.Inputs.EnvironmentConfigSoftwareConfigArgs
* {
* ImageVersion = "composer-3-airflow-2",
* },
* },
* });
* var exampleUserWorkloadsSecret = new Gcp.Composer.UserWorkloadsSecret("example", new()
* {
* Environment = exampleEnvironment.Name,
* Name = "example-secret",
* Data =
* {
* { "username", Std.Base64encode.Invoke(new()
* {
* Input = "username",
* }).Apply(invoke => invoke.Result) },
* { "password", Std.Base64encode.Invoke(new()
* {
* Input = "password",
* }).Apply(invoke => invoke.Result) },
* },
* });
* var example = Gcp.Composer.GetUserWorkloadsSecret.Invoke(new()
* {
* Environment = exampleEnvironment.Name,
* Name = googleComposerUserWorkloadsSecret.Example.Name,
* });
* return new Dictionary
* {
* ["debug"] = example,
* };
* });
* ```
* ```go
* package main
* import (
* "github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/composer"
* "github.com/pulumi/pulumi-std/sdk/go/std"
* "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
* )
* func main() {
* pulumi.Run(func(ctx *pulumi.Context) error {
* exampleEnvironment, err := composer.NewEnvironment(ctx, "example", &composer.EnvironmentArgs{
* Name: pulumi.String("example-environment"),
* Config: &composer.EnvironmentConfigArgs{
* SoftwareConfig: &composer.EnvironmentConfigSoftwareConfigArgs{
* ImageVersion: pulumi.String("composer-3-airflow-2"),
* },
* },
* })
* if err != nil {
* return err
* }
* invokeBase64encode, err := std.Base64encode(ctx, &std.Base64encodeArgs{
* Input: "username",
* }, nil)
* if err != nil {
* return err
* }
* invokeBase64encode1, err := std.Base64encode(ctx, &std.Base64encodeArgs{
* Input: "password",
* }, nil)
* if err != nil {
* return err
* }
* _, err = composer.NewUserWorkloadsSecret(ctx, "example", &composer.UserWorkloadsSecretArgs{
* Environment: exampleEnvironment.Name,
* Name: pulumi.String("example-secret"),
* Data: pulumi.StringMap{
* "username": pulumi.String(invokeBase64encode.Result),
* "password": pulumi.String(invokeBase64encode1.Result),
* },
* })
* if err != nil {
* return err
* }
* example := exampleEnvironment.Name.ApplyT(func(name string) (composer.GetUserWorkloadsSecretResult, error) {
* return composer.GetUserWorkloadsSecretResult(interface{}(composer.LookupUserWorkloadsSecretOutput(ctx, composer.GetUserWorkloadsSecretOutputArgs{
* Environment: name,
* Name: googleComposerUserWorkloadsSecret.Example.Name,
* }, nil))), nil
* }).(composer.GetUserWorkloadsSecretResultOutput)
* ctx.Export("debug", example)
* return nil
* })
* }
* ```
* ```java
* package generated_program;
* import com.pulumi.Context;
* import com.pulumi.Pulumi;
* import com.pulumi.core.Output;
* import com.pulumi.gcp.composer.Environment;
* import com.pulumi.gcp.composer.EnvironmentArgs;
* import com.pulumi.gcp.composer.inputs.EnvironmentConfigArgs;
* import com.pulumi.gcp.composer.inputs.EnvironmentConfigSoftwareConfigArgs;
* import com.pulumi.gcp.composer.UserWorkloadsSecret;
* import com.pulumi.gcp.composer.UserWorkloadsSecretArgs;
* import com.pulumi.gcp.composer.ComposerFunctions;
* import com.pulumi.gcp.composer.inputs.GetUserWorkloadsSecretArgs;
* 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 exampleEnvironment = new Environment("exampleEnvironment", EnvironmentArgs.builder()
* .name("example-environment")
* .config(EnvironmentConfigArgs.builder()
* .softwareConfig(EnvironmentConfigSoftwareConfigArgs.builder()
* .imageVersion("composer-3-airflow-2")
* .build())
* .build())
* .build());
* var exampleUserWorkloadsSecret = new UserWorkloadsSecret("exampleUserWorkloadsSecret", UserWorkloadsSecretArgs.builder()
* .environment(exampleEnvironment.name())
* .name("example-secret")
* .data(Map.ofEntries(
* Map.entry("username", StdFunctions.base64encode(Base64encodeArgs.builder()
* .input("username")
* .build()).result()),
* Map.entry("password", StdFunctions.base64encode(Base64encodeArgs.builder()
* .input("password")
* .build()).result())
* ))
* .build());
* final var example = ComposerFunctions.getUserWorkloadsSecret(GetUserWorkloadsSecretArgs.builder()
* .environment(exampleEnvironment.name())
* .name(googleComposerUserWorkloadsSecret.example().name())
* .build());
* ctx.export("debug", example.applyValue(getUserWorkloadsSecretResult -> getUserWorkloadsSecretResult));
* }
* }
* ```
* ```yaml
* resources:
* exampleEnvironment:
* type: gcp:composer:Environment
* name: example
* properties:
* name: example-environment
* config:
* softwareConfig:
* imageVersion: composer-3-airflow-2
* exampleUserWorkloadsSecret:
* type: gcp:composer:UserWorkloadsSecret
* name: example
* properties:
* environment: ${exampleEnvironment.name}
* name: example-secret
* data:
* username:
* fn::invoke:
* Function: std:base64encode
* Arguments:
* input: username
* Return: result
* password:
* fn::invoke:
* Function: std:base64encode
* Arguments:
* input: password
* Return: result
* variables:
* example:
* fn::invoke:
* Function: gcp:composer:getUserWorkloadsSecret
* Arguments:
* environment: ${exampleEnvironment.name}
* name: ${googleComposerUserWorkloadsSecret.example.name}
* outputs:
* debug: ${example}
* ```
*
* @param argument A collection of arguments for invoking getUserWorkloadsSecret.
* @return A collection of values returned by getUserWorkloadsSecret.
*/
public suspend fun getUserWorkloadsSecret(argument: GetUserWorkloadsSecretPlainArgs): GetUserWorkloadsSecretResult =
getUserWorkloadsSecretResultToKotlin(getUserWorkloadsSecretPlain(argument.toJava()).await())
/**
* @see [getUserWorkloadsSecret].
* @param environment Environment where the Secret is stored.
* @param name Name of the Secret.
* @param project The ID of the project in which the resource belongs.
* If it is not provided, the provider project is used.
* @param region The location or Compute Engine region of the environment.
* @return A collection of values returned by getUserWorkloadsSecret.
*/
public suspend fun getUserWorkloadsSecret(
environment: String,
name: String,
project: String? = null,
region: String? = null,
): GetUserWorkloadsSecretResult {
val argument = GetUserWorkloadsSecretPlainArgs(
environment = environment,
name = name,
project = project,
region = region,
)
return getUserWorkloadsSecretResultToKotlin(getUserWorkloadsSecretPlain(argument.toJava()).await())
}
/**
* @see [getUserWorkloadsSecret].
* @param argument Builder for [com.pulumi.gcp.composer.kotlin.inputs.GetUserWorkloadsSecretPlainArgs].
* @return A collection of values returned by getUserWorkloadsSecret.
*/
public suspend fun getUserWorkloadsSecret(argument: suspend GetUserWorkloadsSecretPlainArgsBuilder.() -> Unit): GetUserWorkloadsSecretResult {
val builder = GetUserWorkloadsSecretPlainArgsBuilder()
builder.argument()
val builtArgument = builder.build()
return getUserWorkloadsSecretResultToKotlin(getUserWorkloadsSecretPlain(builtArgument.toJava()).await())
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy