azure-native.containerinstance.ContainerGroup

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

return await Deployment.RunAsync(() => 
{
    var containerGroup = new AzureNative.ContainerInstance.ContainerGroup("containerGroup", new()
    {
        ContainerGroupName = "demo1",
        Containers = new[]
        {
            new AzureNative.ContainerInstance.Inputs.ContainerArgs
            {
                Command = new[] {},
                EnvironmentVariables = new[] {},
                Image = "nginx",
                Name = "demo1",
                Ports = new[]
                {
                    new AzureNative.ContainerInstance.Inputs.ContainerPortArgs
                    {
                        Port = 80,
                    },
                },
                Resources = new AzureNative.ContainerInstance.Inputs.ResourceRequirementsArgs
                {
                    Requests = new AzureNative.ContainerInstance.Inputs.ResourceRequestsArgs
                    {
                        Cpu = 1,
                        Gpu = new AzureNative.ContainerInstance.Inputs.GpuResourceArgs
                        {
                            Count = 1,
                            Sku = "K80",
                        },
                        MemoryInGB = 1.5,
                    },
                },
                VolumeMounts = new[]
                {
                    new AzureNative.ContainerInstance.Inputs.VolumeMountArgs
                    {
                        MountPath = "/mnt/volume1",
                        Name = "volume1",
                        ReadOnly = false,
                    },
                    new AzureNative.ContainerInstance.Inputs.VolumeMountArgs
                    {
                        MountPath = "/mnt/volume2",
                        Name = "volume2",
                        ReadOnly = false,
                    },
                    new AzureNative.ContainerInstance.Inputs.VolumeMountArgs
                    {
                        MountPath = "/mnt/volume3",
                        Name = "volume3",
                        ReadOnly = true,
                    },
                },
            },
        },
        Diagnostics = new AzureNative.ContainerInstance.Inputs.ContainerGroupDiagnosticsArgs
        {
            LogAnalytics = new AzureNative.ContainerInstance.Inputs.LogAnalyticsArgs
            {
                LogType = "ContainerInsights",
                Metadata = 
                {
                    { "test-key", "test-metadata-value" },
                },
                WorkspaceId = "workspaceid",
                WorkspaceKey = "workspaceKey",
            },
        },
        DnsConfig = new AzureNative.ContainerInstance.Inputs.DnsConfigurationArgs
        {
            NameServers = new[]
            {
                "1.1.1.1",
            },
            Options = "ndots:2",
            SearchDomains = "cluster.local svc.cluster.local",
        },
        Identity = new AzureNative.ContainerInstance.Inputs.ContainerGroupIdentityArgs
        {
            Type = AzureNative.ContainerInstance.ResourceIdentityType.SystemAssigned_UserAssigned,
            UserAssignedIdentities = 
            {
                { "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity-name", null },
            },
        },
        ImageRegistryCredentials = new[] {},
        IpAddress = new AzureNative.ContainerInstance.Inputs.IpAddressArgs
        {
            DnsNameLabel = "dnsnamelabel1",
            Ports = new[]
            {
                new AzureNative.ContainerInstance.Inputs.PortArgs
                {
                    Port = 80,
                    Protocol = "TCP",
                },
            },
            Type = "Public",
        },
        Location = "west us",
        NetworkProfile = new AzureNative.ContainerInstance.Inputs.ContainerGroupNetworkProfileArgs
        {
            Id = "test-network-profile-id",
        },
        OsType = "Linux",
        ResourceGroupName = "demo",
        Volumes = new[]
        {
            new AzureNative.ContainerInstance.Inputs.VolumeArgs
            {
                AzureFile = new AzureNative.ContainerInstance.Inputs.AzureFileVolumeArgs
                {
                    ShareName = "shareName",
                    StorageAccountKey = "accountKey",
                    StorageAccountName = "accountName",
                },
                Name = "volume1",
            },
            new AzureNative.ContainerInstance.Inputs.VolumeArgs
            {
                EmptyDir = null,
                Name = "volume2",
            },
            new AzureNative.ContainerInstance.Inputs.VolumeArgs
            {
                Name = "volume3",
                Secret = 
                {
                    { "secretKey1", "SecretValue1InBase64" },
                    { "secretKey2", "SecretValue2InBase64" },
                },
            },
        },
    });

});

package main

import (
	containerinstance "github.com/pulumi/pulumi-azure-native-sdk/containerinstance"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := containerinstance.NewContainerGroup(ctx, "containerGroup", &containerinstance.ContainerGroupArgs{
			ContainerGroupName: pulumi.String("demo1"),
			Containers: []containerinstance.ContainerArgs{
				{
					Command:              pulumi.StringArray{},
					EnvironmentVariables: containerinstance.EnvironmentVariableArray{},
					Image:                pulumi.String("nginx"),
					Name:                 pulumi.String("demo1"),
					Ports: containerinstance.ContainerPortArray{
						{
							Port: pulumi.Int(80),
						},
					},
					Resources: {
						Requests: {
							Cpu: pulumi.Float64(1),
							Gpu: {
								Count: pulumi.Int(1),
								Sku:   pulumi.String("K80"),
							},
							MemoryInGB: pulumi.Float64(1.5),
						},
					},
					VolumeMounts: containerinstance.VolumeMountArray{
						{
							MountPath: pulumi.String("/mnt/volume1"),
							Name:      pulumi.String("volume1"),
							ReadOnly:  pulumi.Bool(false),
						},
						{
							MountPath: pulumi.String("/mnt/volume2"),
							Name:      pulumi.String("volume2"),
							ReadOnly:  pulumi.Bool(false),
						},
						{
							MountPath: pulumi.String("/mnt/volume3"),
							Name:      pulumi.String("volume3"),
							ReadOnly:  pulumi.Bool(true),
						},
					},
				},
			},
			Diagnostics: containerinstance.ContainerGroupDiagnosticsResponse{
				LogAnalytics: &containerinstance.LogAnalyticsArgs{
					LogType: pulumi.String("ContainerInsights"),
					Metadata: pulumi.StringMap{
						"test-key": pulumi.String("test-metadata-value"),
					},
					WorkspaceId:  pulumi.String("workspaceid"),
					WorkspaceKey: pulumi.String("workspaceKey"),
				},
			},
			DnsConfig: &containerinstance.DnsConfigurationArgs{
				NameServers: pulumi.StringArray{
					pulumi.String("1.1.1.1"),
				},
				Options:       pulumi.String("ndots:2"),
				SearchDomains: pulumi.String("cluster.local svc.cluster.local"),
			},
			Identity: &containerinstance.ContainerGroupIdentityArgs{
				Type: containerinstance.ResourceIdentityType_SystemAssigned_UserAssigned,
				UserAssignedIdentities: pulumi.AnyMap{
					"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity-name": nil,
				},
			},
			ImageRegistryCredentials: containerinstance.ImageRegistryCredentialArray{},
			IpAddress: containerinstance.IpAddressResponse{
				DnsNameLabel: pulumi.String("dnsnamelabel1"),
				Ports: containerinstance.PortArray{
					&containerinstance.PortArgs{
						Port:     pulumi.Int(80),
						Protocol: pulumi.String("TCP"),
					},
				},
				Type: pulumi.String("Public"),
			},
			Location: pulumi.String("west us"),
			NetworkProfile: &containerinstance.ContainerGroupNetworkProfileArgs{
				Id: pulumi.String("test-network-profile-id"),
			},
			OsType:            pulumi.String("Linux"),
			ResourceGroupName: pulumi.String("demo"),
			Volumes: []containerinstance.VolumeArgs{
				{
					AzureFile: {
						ShareName:          pulumi.String("shareName"),
						StorageAccountKey:  pulumi.String("accountKey"),
						StorageAccountName: pulumi.String("accountName"),
					},
					Name: pulumi.String("volume1"),
				},
				{
					EmptyDir: nil,
					Name:     pulumi.String("volume2"),
				},
				{
					Name: pulumi.String("volume3"),
					Secret: {
						"secretKey1": pulumi.String("SecretValue1InBase64"),
						"secretKey2": pulumi.String("SecretValue2InBase64"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.containerinstance.ContainerGroup;
import com.pulumi.azurenative.containerinstance.ContainerGroupArgs;
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) {
        var containerGroup = new ContainerGroup("containerGroup", ContainerGroupArgs.builder()        
            .containerGroupName("demo1")
            .containers(Map.ofEntries(
                Map.entry("command", ),
                Map.entry("environmentVariables", ),
                Map.entry("image", "nginx"),
                Map.entry("name", "demo1"),
                Map.entry("ports", Map.of("port", 80)),
                Map.entry("resources", Map.of("requests", Map.ofEntries(
                    Map.entry("cpu", 1),
                    Map.entry("gpu", Map.ofEntries(
                        Map.entry("count", 1),
                        Map.entry("sku", "K80")
                    )),
                    Map.entry("memoryInGB", 1.5)
                ))),
                Map.entry("volumeMounts",                 
                    Map.ofEntries(
                        Map.entry("mountPath", "/mnt/volume1"),
                        Map.entry("name", "volume1"),
                        Map.entry("readOnly", false)
                    ),
                    Map.ofEntries(
                        Map.entry("mountPath", "/mnt/volume2"),
                        Map.entry("name", "volume2"),
                        Map.entry("readOnly", false)
                    ),
                    Map.ofEntries(
                        Map.entry("mountPath", "/mnt/volume3"),
                        Map.entry("name", "volume3"),
                        Map.entry("readOnly", true)
                    ))
            ))
            .diagnostics(Map.of("logAnalytics", Map.ofEntries(
                Map.entry("logType", "ContainerInsights"),
                Map.entry("metadata", Map.of("test-key", "test-metadata-value")),
                Map.entry("workspaceId", "workspaceid"),
                Map.entry("workspaceKey", "workspaceKey")
            )))
            .dnsConfig(Map.ofEntries(
                Map.entry("nameServers", "1.1.1.1"),
                Map.entry("options", "ndots:2"),
                Map.entry("searchDomains", "cluster.local svc.cluster.local")
            ))
            .identity(Map.ofEntries(
                Map.entry("type", "SystemAssigned, UserAssigned"),
                Map.entry("userAssignedIdentities", Map.of("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity-name", ))
            ))
            .imageRegistryCredentials()
            .ipAddress(Map.ofEntries(
                Map.entry("dnsNameLabel", "dnsnamelabel1"),
                Map.entry("ports", Map.ofEntries(
                    Map.entry("port", 80),
                    Map.entry("protocol", "TCP")
                )),
                Map.entry("type", "Public")
            ))
            .location("west us")
            .networkProfile(Map.of("id", "test-network-profile-id"))
            .osType("Linux")
            .resourceGroupName("demo")
            .volumes(            
                Map.ofEntries(
                    Map.entry("azureFile", Map.ofEntries(
                        Map.entry("shareName", "shareName"),
                        Map.entry("storageAccountKey", "accountKey"),
                        Map.entry("storageAccountName", "accountName")
                    )),
                    Map.entry("name", "volume1")
                ),
                Map.ofEntries(
                    Map.entry("emptyDir", ),
                    Map.entry("name", "volume2")
                ),
                Map.ofEntries(
                    Map.entry("name", "volume3"),
                    Map.entry("secret", Map.ofEntries(
                        Map.entry("secretKey1", "SecretValue1InBase64"),
                        Map.entry("secretKey2", "SecretValue2InBase64")
                    ))
                ))
            .build());

    }
}

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const containerGroup = new azure_native.containerinstance.ContainerGroup("containerGroup", {
    containerGroupName: "demo1",
    containers: [{
        command: [],
        environmentVariables: [],
        image: "nginx",
        name: "demo1",
        ports: [{
            port: 80,
        }],
        resources: {
            requests: {
                cpu: 1,
                gpu: {
                    count: 1,
                    sku: "K80",
                },
                memoryInGB: 1.5,
            },
        },
        volumeMounts: [
            {
                mountPath: "/mnt/volume1",
                name: "volume1",
                readOnly: false,
            },
            {
                mountPath: "/mnt/volume2",
                name: "volume2",
                readOnly: false,
            },
            {
                mountPath: "/mnt/volume3",
                name: "volume3",
                readOnly: true,
            },
        ],
    }],
    diagnostics: {
        logAnalytics: {
            logType: "ContainerInsights",
            metadata: {
                "test-key": "test-metadata-value",
            },
            workspaceId: "workspaceid",
            workspaceKey: "workspaceKey",
        },
    },
    dnsConfig: {
        nameServers: ["1.1.1.1"],
        options: "ndots:2",
        searchDomains: "cluster.local svc.cluster.local",
    },
    identity: {
        type: azure_native.containerinstance.ResourceIdentityType.SystemAssigned_UserAssigned,
        userAssignedIdentities: {
            "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity-name": {},
        },
    },
    imageRegistryCredentials: [],
    ipAddress: {
        dnsNameLabel: "dnsnamelabel1",
        ports: [{
            port: 80,
            protocol: "TCP",
        }],
        type: "Public",
    },
    location: "west us",
    networkProfile: {
        id: "test-network-profile-id",
    },
    osType: "Linux",
    resourceGroupName: "demo",
    volumes: [
        {
            azureFile: {
                shareName: "shareName",
                storageAccountKey: "accountKey",
                storageAccountName: "accountName",
            },
            name: "volume1",
        },
        {
            emptyDir: {},
            name: "volume2",
        },
        {
            name: "volume3",
            secret: {
                secretKey1: "SecretValue1InBase64",
                secretKey2: "SecretValue2InBase64",
            },
        },
    ],
});

import pulumi
import pulumi_azure_native as azure_native

container_group = azure_native.containerinstance.ContainerGroup("containerGroup",
    container_group_name="demo1",
    containers=[{
        "command": [],
        "environmentVariables": [],
        "image": "nginx",
        "name": "demo1",
        "ports": [azure_native.containerinstance.ContainerPortArgs(
            port=80,
        )],
        "resources": {
            "requests": {
                "cpu": 1,
                "gpu": azure_native.containerinstance.GpuResourceArgs(
                    count=1,
                    sku="K80",
                ),
                "memoryInGB": 1.5,
            },
        },
        "volumeMounts": [
            azure_native.containerinstance.VolumeMountArgs(
                mount_path="/mnt/volume1",
                name="volume1",
                read_only=False,
            ),
            azure_native.containerinstance.VolumeMountArgs(
                mount_path="/mnt/volume2",
                name="volume2",
                read_only=False,
            ),
            azure_native.containerinstance.VolumeMountArgs(
                mount_path="/mnt/volume3",
                name="volume3",
                read_only=True,
            ),
        ],
    }],
    diagnostics=azure_native.containerinstance.ContainerGroupDiagnosticsResponseArgs(
        log_analytics=azure_native.containerinstance.LogAnalyticsArgs(
            log_type="ContainerInsights",
            metadata={
                "test-key": "test-metadata-value",
            },
            workspace_id="workspaceid",
            workspace_key="workspaceKey",
        ),
    ),
    dns_config=azure_native.containerinstance.DnsConfigurationArgs(
        name_servers=["1.1.1.1"],
        options="ndots:2",
        search_domains="cluster.local svc.cluster.local",
    ),
    identity=azure_native.containerinstance.ContainerGroupIdentityArgs(
        type=azure_native.containerinstance.ResourceIdentityType.SYSTEM_ASSIGNED_USER_ASSIGNED,
        user_assigned_identities={
            "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity-name": {},
        },
    ),
    image_registry_credentials=[],
    ip_address=azure_native.containerinstance.IpAddressResponseArgs(
        dns_name_label="dnsnamelabel1",
        ports=[azure_native.containerinstance.PortArgs(
            port=80,
            protocol="TCP",
        )],
        type="Public",
    ),
    location="west us",
    network_profile=azure_native.containerinstance.ContainerGroupNetworkProfileArgs(
        id="test-network-profile-id",
    ),
    os_type="Linux",
    resource_group_name="demo",
    volumes=[
        {
            "azureFile": azure_native.containerinstance.AzureFileVolumeArgs(
                share_name="shareName",
                storage_account_key="accountKey",
                storage_account_name="accountName",
            ),
            "name": "volume1",
        },
        azure_native.containerinstance.VolumeArgs(
            empty_dir={},
            name="volume2",
        ),
        azure_native.containerinstance.VolumeArgs(
            name="volume3",
            secret={
                "secretKey1": "SecretValue1InBase64",
                "secretKey2": "SecretValue2InBase64",
            },
        ),
    ])

resources:
  containerGroup:
    type: azure-native:containerinstance:ContainerGroup
    properties:
      containerGroupName: demo1
      containers:
        - command: []
          environmentVariables: []
          image: nginx
          name: demo1
          ports:
            - port: 80
          resources:
            requests:
              cpu: 1
              gpu:
                count: 1
                sku: K80
              memoryInGB: 1.5
          volumeMounts:
            - mountPath: /mnt/volume1
              name: volume1
              readOnly: false
            - mountPath: /mnt/volume2
              name: volume2
              readOnly: false
            - mountPath: /mnt/volume3
              name: volume3
              readOnly: true
      diagnostics:
        logAnalytics:
          logType: ContainerInsights
          metadata:
            test-key: test-metadata-value
          workspaceId: workspaceid
          workspaceKey: workspaceKey
      dnsConfig:
        nameServers:
          - 1.1.1.1
        options: ndots:2
        searchDomains: cluster.local svc.cluster.local
      identity:
        type: SystemAssigned, UserAssigned
        userAssignedIdentities:
          ? /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity-name
          : {}
      imageRegistryCredentials: []
      ipAddress:
        dnsNameLabel: dnsnamelabel1
        ports:
          - port: 80
            protocol: TCP
        type: Public
      location: west us
      networkProfile:
        id: test-network-profile-id
      osType: Linux
      resourceGroupName: demo
      volumes:
        - azureFile:
            shareName: shareName
            storageAccountKey: accountKey
            storageAccountName: accountName
          name: volume1
        - emptyDir: {}
          name: volume2
        - name: volume3
          secret:
            secretKey1: SecretValue1InBase64
            secretKey2: SecretValue2InBase64