upcloud.getStorage

import * as pulumi from "@pulumi/pulumi";
import * as upcloud from "@pulumi/upcloud";
import * as upcloud from "@upcloud/pulumi-upcloud";

// Build server with your latest custom image 
//
// Note that when applied new updated image will cause replacement of the old server (debian.example.tld) 
// with the new server created based on the updated image.This can cause posible data loss 
// if it hasn't been taken into account when planning the service.
const appImage = upcloud.getStorage({
    type: "template",
    nameRegex: "^app_image.*",
    mostRecent: true,
});
const example = new upcloud.Server("example", {
    hostname: "debian.example.tld",
    zone: "fi-hel1",
    networkInterfaces: [{
        type: "public",
    }],
    template: {
        storage: appImage.then(appImage => appImage.id),
    },
});
// Build only new servers with your latest custom image 
//
// Use the lifecycle meta-argument to ignore changes in server's template triggered by new image version
const example2 = new upcloud.Server("example2", {
    hostname: "debian.example2.tld",
    zone: "fi-hel1",
    networkInterfaces: [{
        type: "public",
    }],
    template: {
        storage: appImage.then(appImage => appImage.id),
    },
});

import pulumi
import pulumi_upcloud as upcloud

# Build server with your latest custom image 
#
# Note that when applied new updated image will cause replacement of the old server (debian.example.tld) 
# with the new server created based on the updated image.This can cause posible data loss 
# if it hasn't been taken into account when planning the service.
app_image = upcloud.get_storage(type="template",
    name_regex="^app_image.*",
    most_recent=True)
example = upcloud.Server("example",
    hostname="debian.example.tld",
    zone="fi-hel1",
    network_interfaces=[{
        "type": "public",
    }],
    template={
        "storage": app_image.id,
    })
# Build only new servers with your latest custom image 
#
# Use the lifecycle meta-argument to ignore changes in server's template triggered by new image version
example2 = upcloud.Server("example2",
    hostname="debian.example2.tld",
    zone="fi-hel1",
    network_interfaces=[{
        "type": "public",
    }],
    template={
        "storage": app_image.id,
    })

package main

import (
	"github.com/UpCloudLtd/pulumi-upcloud/sdk/go/upcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Build server with your latest custom image
		//
		// Note that when applied new updated image will cause replacement of the old server (debian.example.tld)
		// with the new server created based on the updated image.This can cause posible data loss
		// if it hasn't been taken into account when planning the service.
		appImage, err := upcloud.LookupStorage(ctx, &upcloud.LookupStorageArgs{
			Type:       pulumi.StringRef("template"),
			NameRegex:  pulumi.StringRef("^app_image.*"),
			MostRecent: pulumi.BoolRef(true),
		}, nil)
		if err != nil {
			return err
		}
		_, err = upcloud.NewServer(ctx, "example", &upcloud.ServerArgs{
			Hostname: pulumi.String("debian.example.tld"),
			Zone:     pulumi.String("fi-hel1"),
			NetworkInterfaces: upcloud.ServerNetworkInterfaceArray{
				&upcloud.ServerNetworkInterfaceArgs{
					Type: pulumi.String("public"),
				},
			},
			Template: &upcloud.ServerTemplateArgs{
				Storage: pulumi.String(appImage.Id),
			},
		})
		if err != nil {
			return err
		}
		// Build only new servers with your latest custom image
		//
		// Use the lifecycle meta-argument to ignore changes in server's template triggered by new image version
		_, err = upcloud.NewServer(ctx, "example2", &upcloud.ServerArgs{
			Hostname: pulumi.String("debian.example2.tld"),
			Zone:     pulumi.String("fi-hel1"),
			NetworkInterfaces: upcloud.ServerNetworkInterfaceArray{
				&upcloud.ServerNetworkInterfaceArgs{
					Type: pulumi.String("public"),
				},
			},
			Template: &upcloud.ServerTemplateArgs{
				Storage: pulumi.String(appImage.Id),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Build server with your latest custom image 
    //
    // Note that when applied new updated image will cause replacement of the old server (debian.example.tld) 
    // with the new server created based on the updated image.This can cause posible data loss 
    // if it hasn't been taken into account when planning the service.
    var appImage = UpCloud.GetStorage.Invoke(new()
    {
        Type = "template",
        NameRegex = "^app_image.*",
        MostRecent = true,
    });

    var example = new UpCloud.Server("example", new()
    {
        Hostname = "debian.example.tld",
        Zone = "fi-hel1",
        NetworkInterfaces = new[]
        {
            new UpCloud.Inputs.ServerNetworkInterfaceArgs
            {
                Type = "public",
            },
        },
        Template = new UpCloud.Inputs.ServerTemplateArgs
        {
            Storage = appImage.Apply(getStorageResult => getStorageResult.Id),
        },
    });

    // Build only new servers with your latest custom image 
    //
    // Use the lifecycle meta-argument to ignore changes in server's template triggered by new image version
    var example2 = new UpCloud.Server("example2", new()
    {
        Hostname = "debian.example2.tld",
        Zone = "fi-hel1",
        NetworkInterfaces = new[]
        {
            new UpCloud.Inputs.ServerNetworkInterfaceArgs
            {
                Type = "public",
            },
        },
        Template = new UpCloud.Inputs.ServerTemplateArgs
        {
            Storage = appImage.Apply(getStorageResult => getStorageResult.Id),
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.upcloud.UpcloudFunctions;
import com.pulumi.upcloud.inputs.GetStorageArgs;
import com.pulumi.upcloud.Server;
import com.pulumi.upcloud.ServerArgs;
import com.pulumi.upcloud.inputs.ServerNetworkInterfaceArgs;
import com.pulumi.upcloud.inputs.ServerTemplateArgs;
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) {
        // Build server with your latest custom image 
        //
        // Note that when applied new updated image will cause replacement of the old server (debian.example.tld) 
        // with the new server created based on the updated image.This can cause posible data loss 
        // if it hasn't been taken into account when planning the service.
        final var appImage = UpcloudFunctions.getStorage(GetStorageArgs.builder()
            .type("template")
            .nameRegex("^app_image.*")
            .mostRecent(true)
            .build());

        var example = new Server("example", ServerArgs.builder()
            .hostname("debian.example.tld")
            .zone("fi-hel1")
            .networkInterfaces(ServerNetworkInterfaceArgs.builder()
                .type("public")
                .build())
            .template(ServerTemplateArgs.builder()
                .storage(appImage.applyValue(getStorageResult -> getStorageResult.id()))
                .build())
            .build());

        // Build only new servers with your latest custom image 
        //
        // Use the lifecycle meta-argument to ignore changes in server's template triggered by new image version
        var example2 = new Server("example2", ServerArgs.builder()
            .hostname("debian.example2.tld")
            .zone("fi-hel1")
            .networkInterfaces(ServerNetworkInterfaceArgs.builder()
                .type("public")
                .build())
            .template(ServerTemplateArgs.builder()
                .storage(appImage.applyValue(getStorageResult -> getStorageResult.id()))
                .build())
            .build());

    }
}

resources:
  example:
    type: upcloud:Server
    properties:
      hostname: debian.example.tld
      zone: fi-hel1
      networkInterfaces:
        - type: public
      template:
        storage: ${appImage.id}
  # Build only new servers with your latest custom image 
  #
  # Use the lifecycle meta-argument to ignore changes in server's template triggered by new image version
  example2:
    type: upcloud:Server
    properties:
      hostname: debian.example2.tld
      zone: fi-hel1
      networkInterfaces:
        - type: public
      template:
        storage: ${appImage.id}
variables:
  # Build server with your latest custom image 
  #
  # Note that when applied new updated image will cause replacement of the old server (debian.example.tld) 
  # with the new server created based on the updated image.This can cause posible data loss 
  # if it hasn't been taken into account when planning the service.
  appImage:
    fn::invoke:
      function: upcloud:getStorage
      arguments:
        type: template
        nameRegex: ^app_image.*
        mostRecent: true

function getStorage(args: GetStorageArgs, opts?: InvokeOptions): Promise<GetStorageResult>
function getStorageOutput(args: GetStorageOutputArgs, opts?: InvokeOptions): Output<GetStorageResult>

def get_storage(access_type: Optional[str] = None,
                id: Optional[str] = None,
                most_recent: Optional[bool] = None,
                name: Optional[str] = None,
                name_regex: Optional[str] = None,
                title: Optional[str] = None,
                type: Optional[str] = None,
                zone: Optional[str] = None,
                opts: Optional[InvokeOptions] = None) -> GetStorageResult
def get_storage_output(access_type: Optional[pulumi.Input[str]] = None,
                id: Optional[pulumi.Input[str]] = None,
                most_recent: Optional[pulumi.Input[bool]] = None,
                name: Optional[pulumi.Input[str]] = None,
                name_regex: Optional[pulumi.Input[str]] = None,
                title: Optional[pulumi.Input[str]] = None,
                type: Optional[pulumi.Input[str]] = None,
                zone: Optional[pulumi.Input[str]] = None,
                opts: Optional[InvokeOptions] = None) -> Output[GetStorageResult]

func LookupStorage(ctx *Context, args *LookupStorageArgs, opts ...InvokeOption) (*LookupStorageResult, error)
func LookupStorageOutput(ctx *Context, args *LookupStorageOutputArgs, opts ...InvokeOption) LookupStorageResultOutput

public static class GetStorage 
{
    public static Task<GetStorageResult> InvokeAsync(GetStorageArgs args, InvokeOptions? opts = null)
    public static Output<GetStorageResult> Invoke(GetStorageInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetStorageResult> getStorage(GetStorageArgs args, InvokeOptions options)
public static Output<GetStorageResult> getStorage(GetStorageArgs args, InvokeOptions options)

fn::invoke:
  function: upcloud:index/getStorage:getStorage
  arguments:
    # arguments dictionary