digitalocean.getMicrodropletImage

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

const byid = digitalocean.getMicrodropletImage({
    id: "4a2c9f10-3d18-4b6a-9e3d-2b7f8e0f1c11",
});
const byname = digitalocean.getMicrodropletImage({
    name: "my-app-v1",
});

import pulumi
import pulumi_digitalocean as digitalocean

byid = digitalocean.get_microdroplet_image(id="4a2c9f10-3d18-4b6a-9e3d-2b7f8e0f1c11")
byname = digitalocean.get_microdroplet_image(name="my-app-v1")

package main

import (
	"github.com/pulumi/pulumi-digitalocean/sdk/v4/go/digitalocean"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := digitalocean.GetMicrodropletImage(ctx, &digitalocean.LookupMicrodropletImageArgs{
			Id: pulumi.StringRef("4a2c9f10-3d18-4b6a-9e3d-2b7f8e0f1c11"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = digitalocean.GetMicrodropletImage(ctx, &digitalocean.LookupMicrodropletImageArgs{
			Name: pulumi.StringRef("my-app-v1"),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var byid = DigitalOcean.GetMicrodropletImage.Invoke(new()
    {
        Id = "4a2c9f10-3d18-4b6a-9e3d-2b7f8e0f1c11",
    });

    var byname = DigitalOcean.GetMicrodropletImage.Invoke(new()
    {
        Name = "my-app-v1",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.digitalocean.DigitaloceanFunctions;
import com.pulumi.digitalocean.inputs.GetMicrodropletImageArgs;
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 byid = DigitaloceanFunctions.getMicrodropletImage(GetMicrodropletImageArgs.builder()
            .id("4a2c9f10-3d18-4b6a-9e3d-2b7f8e0f1c11")
            .build());

        final var byname = DigitaloceanFunctions.getMicrodropletImage(GetMicrodropletImageArgs.builder()
            .name("my-app-v1")
            .build());

    }
}

variables:
  byid:
    fn::invoke:
      function: digitalocean:getMicrodropletImage
      arguments:
        id: 4a2c9f10-3d18-4b6a-9e3d-2b7f8e0f1c11
  byname:
    fn::invoke:
      function: digitalocean:getMicrodropletImage
      arguments:
        name: my-app-v1

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

data "digitalocean_getmicrodropletimage" "byid" {
  id = "4a2c9f10-3d18-4b6a-9e3d-2b7f8e0f1c11"
}
data "digitalocean_getmicrodropletimage" "byname" {
  name = "my-app-v1"
}

function getMicrodropletImage(args: GetMicrodropletImageArgs, opts?: InvokeOptions): Promise<GetMicrodropletImageResult>
function getMicrodropletImageOutput(args: GetMicrodropletImageOutputArgs, opts?: InvokeOptions): Output<GetMicrodropletImageResult>

def get_microdroplet_image(id: Optional[str] = None,
                           name: Optional[str] = None,
                           opts: Optional[InvokeOptions] = None) -> GetMicrodropletImageResult
def get_microdroplet_image_output(id: pulumi.Input[Optional[str]] = None,
                           name: pulumi.Input[Optional[str]] = None,
                           opts: Optional[InvokeOptions] = None) -> Output[GetMicrodropletImageResult]

func LookupMicrodropletImage(ctx *Context, args *LookupMicrodropletImageArgs, opts ...InvokeOption) (*LookupMicrodropletImageResult, error)
func LookupMicrodropletImageOutput(ctx *Context, args *LookupMicrodropletImageOutputArgs, opts ...InvokeOption) LookupMicrodropletImageResultOutput

public static class GetMicrodropletImage 
{
    public static Task<GetMicrodropletImageResult> InvokeAsync(GetMicrodropletImageArgs args, InvokeOptions? opts = null)
    public static Output<GetMicrodropletImageResult> Invoke(GetMicrodropletImageInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetMicrodropletImageResult> getMicrodropletImage(GetMicrodropletImageArgs args, InvokeOptions options)
public static Output<GetMicrodropletImageResult> getMicrodropletImage(GetMicrodropletImageArgs args, InvokeOptions options)

fn::invoke:
  function: digitalocean:index/getMicrodropletImage:getMicrodropletImage
  arguments:
    # arguments dictionary

data "digitalocean_get_microdroplet_image" "name" {
    # arguments
}