com.pulumi.azure.compute.kotlin.SharedImageVersion.kt Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of pulumi-azure-kotlin Show documentation
Show all versions of pulumi-azure-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.azure.compute.kotlin
import com.pulumi.azure.compute.kotlin.outputs.SharedImageVersionTargetRegion
import com.pulumi.azure.compute.kotlin.outputs.SharedImageVersionTargetRegion.Companion.toKotlin
import com.pulumi.core.Output
import com.pulumi.kotlin.KotlinCustomResource
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.ResourceMapper
import com.pulumi.kotlin.options.CustomResourceOptions
import com.pulumi.kotlin.options.CustomResourceOptionsBuilder
import com.pulumi.resources.Resource
import kotlin.Boolean
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.collections.Map
/**
* Builder for [SharedImageVersion].
*/
@PulumiTagMarker
public class SharedImageVersionResourceBuilder internal constructor() {
public var name: String? = null
public var args: SharedImageVersionArgs = SharedImageVersionArgs()
public var opts: CustomResourceOptions = CustomResourceOptions()
/**
* @param name The _unique_ name of the resulting resource.
*/
public fun name(`value`: String) {
this.name = value
}
/**
* @param block The arguments to use to populate this resource's properties.
*/
public suspend fun args(block: suspend SharedImageVersionArgsBuilder.() -> Unit) {
val builder = SharedImageVersionArgsBuilder()
block(builder)
this.args = builder.build()
}
/**
* @param block A bag of options that control this resource's behavior.
*/
public suspend fun opts(block: suspend CustomResourceOptionsBuilder.() -> Unit) {
this.opts = com.pulumi.kotlin.options.CustomResourceOptions.opts(block)
}
internal fun build(): SharedImageVersion {
val builtJavaResource = com.pulumi.azure.compute.SharedImageVersion(
this.name,
this.args.toJava(),
this.opts.toJava(),
)
return SharedImageVersion(builtJavaResource)
}
}
/**
* Manages a Version of a Shared Image within a Shared Image Gallery.
* ## Example Usage
*
* ```typescript
* import * as pulumi from "@pulumi/pulumi";
* import * as azure from "@pulumi/azure";
* const existing = azure.compute.getImage({
* name: "search-api",
* resourceGroupName: "packerimages",
* });
* const existingGetSharedImage = azure.compute.getSharedImage({
* name: "existing-image",
* galleryName: "existing_gallery",
* resourceGroupName: "existing-resources",
* });
* const example = new azure.compute.SharedImageVersion("example", {
* name: "0.0.1",
* galleryName: existingGetSharedImage.then(existingGetSharedImage => existingGetSharedImage.galleryName),
* imageName: existingGetSharedImage.then(existingGetSharedImage => existingGetSharedImage.name),
* resourceGroupName: existingGetSharedImage.then(existingGetSharedImage => existingGetSharedImage.resourceGroupName),
* location: existingGetSharedImage.then(existingGetSharedImage => existingGetSharedImage.location),
* managedImageId: existing.then(existing => existing.id),
* targetRegions: [{
* name: existingGetSharedImage.then(existingGetSharedImage => existingGetSharedImage.location),
* regionalReplicaCount: 5,
* storageAccountType: "Standard_LRS",
* }],
* });
* ```
* ```python
* import pulumi
* import pulumi_azure as azure
* existing = azure.compute.get_image(name="search-api",
* resource_group_name="packerimages")
* existing_get_shared_image = azure.compute.get_shared_image(name="existing-image",
* gallery_name="existing_gallery",
* resource_group_name="existing-resources")
* example = azure.compute.SharedImageVersion("example",
* name="0.0.1",
* gallery_name=existing_get_shared_image.gallery_name,
* image_name=existing_get_shared_image.name,
* resource_group_name=existing_get_shared_image.resource_group_name,
* location=existing_get_shared_image.location,
* managed_image_id=existing.id,
* target_regions=[{
* "name": existing_get_shared_image.location,
* "regional_replica_count": 5,
* "storage_account_type": "Standard_LRS",
* }])
* ```
* ```csharp
* using System.Collections.Generic;
* using System.Linq;
* using Pulumi;
* using Azure = Pulumi.Azure;
* return await Deployment.RunAsync(() =>
* {
* var existing = Azure.Compute.GetImage.Invoke(new()
* {
* Name = "search-api",
* ResourceGroupName = "packerimages",
* });
* var existingGetSharedImage = Azure.Compute.GetSharedImage.Invoke(new()
* {
* Name = "existing-image",
* GalleryName = "existing_gallery",
* ResourceGroupName = "existing-resources",
* });
* var example = new Azure.Compute.SharedImageVersion("example", new()
* {
* Name = "0.0.1",
* GalleryName = existingGetSharedImage.Apply(getSharedImageResult => getSharedImageResult.GalleryName),
* ImageName = existingGetSharedImage.Apply(getSharedImageResult => getSharedImageResult.Name),
* ResourceGroupName = existingGetSharedImage.Apply(getSharedImageResult => getSharedImageResult.ResourceGroupName),
* Location = existingGetSharedImage.Apply(getSharedImageResult => getSharedImageResult.Location),
* ManagedImageId = existing.Apply(getImageResult => getImageResult.Id),
* TargetRegions = new[]
* {
* new Azure.Compute.Inputs.SharedImageVersionTargetRegionArgs
* {
* Name = existingGetSharedImage.Apply(getSharedImageResult => getSharedImageResult.Location),
* RegionalReplicaCount = 5,
* StorageAccountType = "Standard_LRS",
* },
* },
* });
* });
* ```
* ```go
* package main
* import (
* "github.com/pulumi/pulumi-azure/sdk/v5/go/azure/compute"
* "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
* )
* func main() {
* pulumi.Run(func(ctx *pulumi.Context) error {
* existing, err := compute.LookupImage(ctx, &compute.LookupImageArgs{
* Name: pulumi.StringRef("search-api"),
* ResourceGroupName: "packerimages",
* }, nil)
* if err != nil {
* return err
* }
* existingGetSharedImage, err := compute.LookupSharedImage(ctx, &compute.LookupSharedImageArgs{
* Name: "existing-image",
* GalleryName: "existing_gallery",
* ResourceGroupName: "existing-resources",
* }, nil)
* if err != nil {
* return err
* }
* _, err = compute.NewSharedImageVersion(ctx, "example", &compute.SharedImageVersionArgs{
* Name: pulumi.String("0.0.1"),
* GalleryName: pulumi.String(existingGetSharedImage.GalleryName),
* ImageName: pulumi.String(existingGetSharedImage.Name),
* ResourceGroupName: pulumi.String(existingGetSharedImage.ResourceGroupName),
* Location: pulumi.String(existingGetSharedImage.Location),
* ManagedImageId: pulumi.String(existing.Id),
* TargetRegions: compute.SharedImageVersionTargetRegionArray{
* &compute.SharedImageVersionTargetRegionArgs{
* Name: pulumi.String(existingGetSharedImage.Location),
* RegionalReplicaCount: pulumi.Int(5),
* StorageAccountType: pulumi.String("Standard_LRS"),
* },
* },
* })
* 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.azure.compute.ComputeFunctions;
* import com.pulumi.azure.compute.inputs.GetImageArgs;
* import com.pulumi.azure.compute.inputs.GetSharedImageArgs;
* import com.pulumi.azure.compute.SharedImageVersion;
* import com.pulumi.azure.compute.SharedImageVersionArgs;
* import com.pulumi.azure.compute.inputs.SharedImageVersionTargetRegionArgs;
* 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 existing = ComputeFunctions.getImage(GetImageArgs.builder()
* .name("search-api")
* .resourceGroupName("packerimages")
* .build());
* final var existingGetSharedImage = ComputeFunctions.getSharedImage(GetSharedImageArgs.builder()
* .name("existing-image")
* .galleryName("existing_gallery")
* .resourceGroupName("existing-resources")
* .build());
* var example = new SharedImageVersion("example", SharedImageVersionArgs.builder()
* .name("0.0.1")
* .galleryName(existingGetSharedImage.applyValue(getSharedImageResult -> getSharedImageResult.galleryName()))
* .imageName(existingGetSharedImage.applyValue(getSharedImageResult -> getSharedImageResult.name()))
* .resourceGroupName(existingGetSharedImage.applyValue(getSharedImageResult -> getSharedImageResult.resourceGroupName()))
* .location(existingGetSharedImage.applyValue(getSharedImageResult -> getSharedImageResult.location()))
* .managedImageId(existing.applyValue(getImageResult -> getImageResult.id()))
* .targetRegions(SharedImageVersionTargetRegionArgs.builder()
* .name(existingGetSharedImage.applyValue(getSharedImageResult -> getSharedImageResult.location()))
* .regionalReplicaCount(5)
* .storageAccountType("Standard_LRS")
* .build())
* .build());
* }
* }
* ```
* ```yaml
* resources:
* example:
* type: azure:compute:SharedImageVersion
* properties:
* name: 0.0.1
* galleryName: ${existingGetSharedImage.galleryName}
* imageName: ${existingGetSharedImage.name}
* resourceGroupName: ${existingGetSharedImage.resourceGroupName}
* location: ${existingGetSharedImage.location}
* managedImageId: ${existing.id}
* targetRegions:
* - name: ${existingGetSharedImage.location}
* regionalReplicaCount: 5
* storageAccountType: Standard_LRS
* variables:
* existing:
* fn::invoke:
* Function: azure:compute:getImage
* Arguments:
* name: search-api
* resourceGroupName: packerimages
* existingGetSharedImage:
* fn::invoke:
* Function: azure:compute:getSharedImage
* Arguments:
* name: existing-image
* galleryName: existing_gallery
* resourceGroupName: existing-resources
* ```
*
* ## Import
* Shared Image Versions can be imported using the `resource id`, e.g.
* ```sh
* $ pulumi import azure:compute/sharedImageVersion:SharedImageVersion version /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Compute/galleries/gallery1/images/image1/versions/1.2.3
* ```
*/
public class SharedImageVersion internal constructor(
override val javaResource: com.pulumi.azure.compute.SharedImageVersion,
) : KotlinCustomResource(javaResource, SharedImageVersionMapper) {
/**
* URI of the Azure Storage Blob used to create the Image Version. Changing this forces a new resource to be created.
* > **NOTE:** You must specify exact one of `blob_uri`, `managed_image_id` and `os_disk_snapshot_id`.
* > **NOTE:** `blob_uri` and `storage_account_id` must be specified together
*/
public val blobUri: Output?
get() = javaResource.blobUri().applyValue({ args0 -> args0.map({ args0 -> args0 }).orElse(null) })
/**
* Specifies whether this Shared Image Version can be deleted from the Azure Regions this is replicated to. Defaults to `false`. Changing this forces a new resource to be created.
*/
public val deletionOfReplicatedLocationsEnabled: Output?
get() = javaResource.deletionOfReplicatedLocationsEnabled().applyValue({ args0 ->
args0.map({ args0 -> args0 }).orElse(null)
})
/**
* The end of life date in RFC3339 format of the Image Version.
*/
public val endOfLifeDate: Output?
get() = javaResource.endOfLifeDate().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* Should this Image Version be excluded from the `latest` filter? If set to `true` this Image Version won't be returned for the `latest` version. Defaults to `false`.
*/
public val excludeFromLatest: Output?
get() = javaResource.excludeFromLatest().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The name of the Shared Image Gallery in which the Shared Image exists. Changing this forces a new resource to be created.
*/
public val galleryName: Output
get() = javaResource.galleryName().applyValue({ args0 -> args0 })
/**
* The name of the Shared Image within the Shared Image Gallery in which this Version should be created. Changing this forces a new resource to be created.
*/
public val imageName: Output
get() = javaResource.imageName().applyValue({ args0 -> args0 })
/**
* The Azure Region in which the Shared Image Gallery exists. Changing this forces a new resource to be created.
*/
public val location: Output
get() = javaResource.location().applyValue({ args0 -> args0 })
/**
* The ID of the Managed Image or Virtual Machine ID which should be used for this Shared Image Version. Changing this forces a new resource to be created.
* > **NOTE:** The ID can be sourced from the `azure.compute.Image` data source or resource
* > **NOTE:** You must specify exact one of `blob_uri`, `managed_image_id` and `os_disk_snapshot_id`.
*/
public val managedImageId: Output?
get() = javaResource.managedImageId().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The version number for this Image Version, such as `1.0.0`. Changing this forces a new resource to be created.
*/
public val name: Output
get() = javaResource.name().applyValue({ args0 -> args0 })
/**
* The ID of the OS disk snapshot which should be used for this Shared Image Version. Changing this forces a new resource to be created.
* > **NOTE:** You must specify exact one of `blob_uri`, `managed_image_id` and `os_disk_snapshot_id`.
*/
public val osDiskSnapshotId: Output?
get() = javaResource.osDiskSnapshotId().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* Mode to be used for replication. Possible values are `Full` and `Shallow`. Defaults to `Full`. Changing this forces a new resource to be created.
*/
public val replicationMode: Output?
get() = javaResource.replicationMode().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The name of the Resource Group in which the Shared Image Gallery exists. Changing this forces a new resource to be created.
*/
public val resourceGroupName: Output
get() = javaResource.resourceGroupName().applyValue({ args0 -> args0 })
/**
* The ID of the Storage Account where the Blob exists. Changing this forces a new resource to be created.
* > **NOTE:** `blob_uri` and `storage_account_id` must be specified together
*/
public val storageAccountId: Output?
get() = javaResource.storageAccountId().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* A collection of tags which should be applied to this resource.
*/
public val tags: Output>?
get() = javaResource.tags().applyValue({ args0 ->
args0.map({ args0 ->
args0.map({ args0 ->
args0.key.to(args0.value)
}).toMap()
}).orElse(null)
})
/**
* One or more `target_region` blocks as documented below.
*/
public val targetRegions: Output>
get() = javaResource.targetRegions().applyValue({ args0 ->
args0.map({ args0 ->
args0.let({ args0 -> toKotlin(args0) })
})
})
}
public object SharedImageVersionMapper : ResourceMapper {
override fun supportsMappingOfType(javaResource: Resource): Boolean =
com.pulumi.azure.compute.SharedImageVersion::class == javaResource::class
override fun map(javaResource: Resource): SharedImageVersion = SharedImageVersion(
javaResource as
com.pulumi.azure.compute.SharedImageVersion,
)
}
/**
* @see [SharedImageVersion].
* @param name The _unique_ name of the resulting resource.
* @param block Builder for [SharedImageVersion].
*/
public suspend fun sharedImageVersion(
name: String,
block: suspend SharedImageVersionResourceBuilder.() -> Unit,
): SharedImageVersion {
val builder = SharedImageVersionResourceBuilder()
builder.name(name)
block(builder)
return builder.build()
}
/**
* @see [SharedImageVersion].
* @param name The _unique_ name of the resulting resource.
*/
public fun sharedImageVersion(name: String): SharedImageVersion {
val builder = SharedImageVersionResourceBuilder()
builder.name(name)
return builder.build()
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy