proxmoxve.getContainer

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

const testContainer = proxmoxve.getContainer({
    nodeName: "test",
    vmId: 100,
});

import pulumi
import pulumi_proxmoxve as proxmoxve

test_container = proxmoxve.get_container(node_name="test",
    vm_id=100)

package main

import (
	"github.com/muhlba91/pulumi-proxmoxve/sdk/v6/go/proxmoxve"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := proxmoxve.GetContainer(ctx, &proxmoxve.GetContainerArgs{
			NodeName: "test",
			VmId:     100,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var testContainer = ProxmoxVE.GetContainer.Invoke(new()
    {
        NodeName = "test",
        VmId = 100,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.proxmoxve.ProxmoxveFunctions;
import com.pulumi.proxmoxve.inputs.GetContainerArgs;
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 testContainer = ProxmoxveFunctions.getContainer(GetContainerArgs.builder()
            .nodeName("test")
            .vmId(100)
            .build());

    }
}

variables:
  testContainer:
    fn::invoke:
      function: proxmoxve:getContainer
      arguments:
        nodeName: test
        vmId: 100

function getContainer(args: GetContainerArgs, opts?: InvokeOptions): Promise<GetContainerResult>
function getContainerOutput(args: GetContainerOutputArgs, opts?: InvokeOptions): Output<GetContainerResult>

def get_container(node_name: Optional[str] = None,
                  status: Optional[str] = None,
                  template: Optional[bool] = None,
                  vm_id: Optional[int] = None,
                  opts: Optional[InvokeOptions] = None) -> GetContainerResult
def get_container_output(node_name: Optional[pulumi.Input[str]] = None,
                  status: Optional[pulumi.Input[str]] = None,
                  template: Optional[pulumi.Input[bool]] = None,
                  vm_id: Optional[pulumi.Input[int]] = None,
                  opts: Optional[InvokeOptions] = None) -> Output[GetContainerResult]

func GetContainer(ctx *Context, args *GetContainerArgs, opts ...InvokeOption) (*GetContainerResult, error)
func GetContainerOutput(ctx *Context, args *GetContainerOutputArgs, opts ...InvokeOption) GetContainerResultOutput

public static class GetContainer 
{
    public static Task<GetContainerResult> InvokeAsync(GetContainerArgs args, InvokeOptions? opts = null)
    public static Output<GetContainerResult> Invoke(GetContainerInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetContainerResult> getContainer(GetContainerArgs args, InvokeOptions options)
public static Output<GetContainerResult> getContainer(GetContainerArgs args, InvokeOptions options)

fn::invoke:
  function: proxmoxve:index/getContainer:getContainer
  arguments:
    # arguments dictionary