confluentcloud.getPlugin

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

export = async () => {
    const example = await confluentcloud.getPlugin({
        id: "ccp-abc123",
        environment: {
            id: "env-xyz456",
        },
    });
    return {
        example: example,
    };
}

import pulumi
import pulumi_confluentcloud as confluentcloud

example = confluentcloud.get_plugin(id="ccp-abc123",
    environment={
        "id": "env-xyz456",
    })
pulumi.export("example", example)

package main

import (
	"github.com/pulumi/pulumi-confluentcloud/sdk/v2/go/confluentcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := confluentcloud.GetPlugin(ctx, &confluentcloud.LookupPluginArgs{
			Id: "ccp-abc123",
			Environment: confluentcloud.GetPluginEnvironment{
				Id: "env-xyz456",
			},
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("example", example)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = ConfluentCloud.GetPlugin.Invoke(new()
    {
        Id = "ccp-abc123",
        Environment = new ConfluentCloud.Inputs.GetPluginEnvironmentInputArgs
        {
            Id = "env-xyz456",
        },
    });

    return new Dictionary<string, object?>
    {
        ["example"] = example,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.confluentcloud.ConfluentcloudFunctions;
import com.pulumi.confluentcloud.inputs.GetPluginArgs;
import com.pulumi.confluentcloud.inputs.GetPluginEnvironmentArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 example = ConfluentcloudFunctions.getPlugin(GetPluginArgs.builder()
            .id("ccp-abc123")
            .environment(GetPluginEnvironmentArgs.builder()
                .id("env-xyz456")
                .build())
            .build());

        ctx.export("example", example);
    }
}

variables:
  example:
    fn::invoke:
      function: confluentcloud:getPlugin
      arguments:
        id: ccp-abc123
        environment:
          id: env-xyz456
outputs:
  example: ${example}

pulumi {
  required_providers {
    confluentcloud = {
      source = "pulumi/confluentcloud"
    }
  }
}

data "confluentcloud_getplugin" "example" {
  id = "ccp-abc123"
  environment = {
    id = "env-xyz456"
  }
}

output "example" {
  value = data.confluentcloud_getplugin.example
}

function getPlugin(args: GetPluginArgs, opts?: InvokeOptions): Promise<GetPluginResult>
function getPluginOutput(args: GetPluginOutputArgs, opts?: InvokeOutputOptions): Output<GetPluginResult>

def get_plugin(environment: Optional[GetPluginEnvironment] = None,
               id: Optional[str] = None,
               opts: Optional[InvokeOptions] = None) -> GetPluginResult
def get_plugin_output(environment: pulumi.Input[Optional[GetPluginEnvironmentArgs]] = None,
               id: pulumi.Input[Optional[str]] = None,
               opts: Optional[InvokeOutputOptions] = None) -> Output[GetPluginResult]

func LookupPlugin(ctx *Context, args *LookupPluginArgs, opts ...InvokeOption) (*LookupPluginResult, error)
func LookupPluginOutput(ctx *Context, args *LookupPluginOutputArgs, opts ...InvokeOption) LookupPluginResultOutput

public static class GetPlugin 
{
    public static Task<GetPluginResult> InvokeAsync(GetPluginArgs args, InvokeOptions? opts = null)
    public static Output<GetPluginResult> Invoke(GetPluginInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetPluginResult> Invoke(GetPluginInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetPluginResult> getPlugin(GetPluginArgs args, InvokeOptions options)
public static Output<GetPluginResult> getPlugin(GetPluginArgs args, InvokeOptions options)
public static Output<GetPluginResult> getPlugin(GetPluginArgs args, InvokeOutputOptions options)

fn::invoke:
  function: confluentcloud:index/getPlugin:getPlugin
  arguments:
    # arguments dictionary

data "confluentcloud_get_plugin" "name" {
    # arguments
}