aws.lambdamicrovms.Image

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

const current = aws.getPartition({});
const currentGetRegion = aws.getRegion({});
const example = new aws.iam.Role("example", {
    name: "example",
    assumeRolePolicy: JSON.stringify({
        Version: "2012-10-17",
        Statement: [{
            Action: "sts:AssumeRole",
            Effect: "Allow",
            Principal: {
                Service: "lambda.amazonaws.com",
            },
        }],
    }),
});
const exampleBucket = new aws.s3.Bucket("example", {bucket: "example"});
const exampleRolePolicy = new aws.iam.RolePolicy("example", {
    name: "example",
    role: example.id,
    policy: pulumi.jsonStringify({
        Version: "2012-10-17",
        Statement: [{
            Action: ["s3:GetObject"],
            Effect: "Allow",
            Resource: pulumi.interpolate`${exampleBucket.arn}/*`,
        }],
    }),
});
const exampleBucketObjectv2 = new aws.s3.BucketObjectv2("example", {
    bucket: exampleBucket.bucket,
    key: "code.zip",
    source: new pulumi.asset.FileAsset("code.zip"),
});
const exampleImage = new aws.lambdamicrovms.Image("example", {
    codeArtifact: {
        uri: pulumi.interpolate`s3://${exampleBucket.bucket}/${exampleBucketObjectv2.key}`,
    },
    name: "example",
    baseImageArn: Promise.all([current, currentGetRegion]).then(([current, currentGetRegion]) => `arn:${current.partition}:lambda:${currentGetRegion.region}:aws:microvm-image:al2023-1`),
    buildRoleArn: example.arn,
});

import pulumi
import json
import pulumi_aws as aws

current = aws.get_partition()
current_get_region = aws.get_region()
example = aws.iam.Role("example",
    name="example",
    assume_role_policy=json.dumps({
        "Version": "2012-10-17",
        "Statement": [{
            "Action": "sts:AssumeRole",
            "Effect": "Allow",
            "Principal": {
                "Service": "lambda.amazonaws.com",
            },
        }],
    }))
example_bucket = aws.s3.Bucket("example", bucket="example")
example_role_policy = aws.iam.RolePolicy("example",
    name="example",
    role=example.id,
    policy=pulumi.Output.json_dumps({
        "Version": "2012-10-17",
        "Statement": [{
            "Action": ["s3:GetObject"],
            "Effect": "Allow",
            "Resource": example_bucket.arn.apply(lambda arn: f"{arn}/*"),
        }],
    }))
example_bucket_objectv2 = aws.s3.BucketObjectv2("example",
    bucket=example_bucket.bucket,
    key="code.zip",
    source=pulumi.FileAsset("code.zip"))
example_image = aws.lambdamicrovms.Image("example",
    code_artifact={
        "uri": pulumi.Output.all(
            bucket=example_bucket.bucket,
            key=example_bucket_objectv2.key
).apply(lambda resolved_outputs: f"s3://{resolved_outputs['bucket']}/{resolved_outputs['key']}")
,
    },
    name="example",
    base_image_arn=f"arn:{current.partition}:lambda:{current_get_region.region}:aws:microvm-image:al2023-1",
    build_role_arn=example.arn)

package main

import (
	"encoding/json"
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lambdamicrovms"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		current, err := aws.GetPartition(ctx, &aws.GetPartitionArgs{}, nil)
		if err != nil {
			return err
		}
		currentGetRegion, err := aws.GetRegion(ctx, &aws.GetRegionArgs{}, nil)
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Version": "2012-10-17",
			"Statement": []map[string]interface{}{
				map[string]interface{}{
					"Action": "sts:AssumeRole",
					"Effect": "Allow",
					"Principal": map[string]string{
						"Service": "lambda.amazonaws.com",
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		example, err := iam.NewRole(ctx, "example", &iam.RoleArgs{
			Name:             pulumi.String("example"),
			AssumeRolePolicy: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		exampleBucket, err := s3.NewBucket(ctx, "example", &s3.BucketArgs{
			Bucket: pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		_, err = iam.NewRolePolicy(ctx, "example", &iam.RolePolicyArgs{
			Name: pulumi.String("example"),
			Role: example.ID().ToIDOutput().ToStringOutput(),
			Policy: exampleBucket.Arn.ApplyT(func(arn string) (pulumi.String, error) {
				var _zero pulumi.String
				tmpJSON1, err := json.Marshal(map[string]interface{}{
					"Version": "2012-10-17",
					"Statement": []map[string]interface{}{
						map[string]interface{}{
							"Action": []string{
								"s3:GetObject",
							},
							"Effect":   "Allow",
							"Resource": fmt.Sprintf("%v/*", arn),
						},
					},
				})
				if err != nil {
					return _zero, err
				}
				json1 := string(tmpJSON1)
				return pulumi.String(json1), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		exampleBucketObjectv2, err := s3.NewBucketObjectv2(ctx, "example", &s3.BucketObjectv2Args{
			Bucket: exampleBucket.Bucket,
			Key:    pulumi.String("code.zip"),
			Source: pulumi.NewFileAsset("code.zip"),
		})
		if err != nil {
			return err
		}
		_, err = lambdamicrovms.NewImage(ctx, "example", &lambdamicrovms.ImageArgs{
			CodeArtifact: &lambdamicrovms.ImageCodeArtifactArgs{
				Uri: pulumi.All(exampleBucket.Bucket, exampleBucketObjectv2.Key).ApplyT(func(_args []interface{}) (string, error) {
					bucket := _args[0].(string)
					key := _args[1].(string)
					return fmt.Sprintf("s3://%v/%v", bucket, key), nil
				}).(pulumi.StringOutput),
			},
			Name:         pulumi.String("example"),
			BaseImageArn: pulumi.Sprintf("arn:%v:lambda:%v:aws:microvm-image:al2023-1", current.Partition, currentGetRegion.Region),
			BuildRoleArn: example.Arn,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var current = Aws.GetPartition.Invoke();

    var currentGetRegion = Aws.GetRegion.Invoke();

    var example = new Aws.Iam.Role("example", new()
    {
        Name = "example",
        AssumeRolePolicy = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["Version"] = "2012-10-17",
            ["Statement"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["Action"] = "sts:AssumeRole",
                    ["Effect"] = "Allow",
                    ["Principal"] = new Dictionary<string, object?>
                    {
                        ["Service"] = "lambda.amazonaws.com",
                    },
                },
            },
        }),
    });

    var exampleBucket = new Aws.S3.Bucket("example", new()
    {
        BucketName = "example",
    });

    var exampleRolePolicy = new Aws.Iam.RolePolicy("example", new()
    {
        Name = "example",
        Role = example.Id,
        Policy = Output.JsonSerialize(Output.Create(new Dictionary<string, object?>
        {
            ["Version"] = "2012-10-17",
            ["Statement"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["Action"] = new[]
                    {
                        "s3:GetObject",
                    },
                    ["Effect"] = "Allow",
                    ["Resource"] = exampleBucket.Arn.Apply(arn => $"{arn}/*"),
                },
            },
        })),
    });

    var exampleBucketObjectv2 = new Aws.S3.BucketObjectv2("example", new()
    {
        Bucket = exampleBucket.BucketName,
        Key = "code.zip",
        Source = new FileAsset("code.zip"),
    });

    var exampleImage = new Aws.LambdaMicroVMs.Image("example", new()
    {
        CodeArtifact = new Aws.LambdaMicroVMs.Inputs.ImageCodeArtifactArgs
        {
            Uri = Output.Tuple(exampleBucket.BucketName, exampleBucketObjectv2.Key).Apply(values =>
            {
                var bucket = values.Item1;
                var key = values.Item2;
                return $"s3://{bucket}/{key}";
            }),
        },
        Name = "example",
        BaseImageArn = Output.Tuple(current, currentGetRegion).Apply(values =>
        {
            var current = values.Item1;
            var currentGetRegion = values.Item2;
            return $"arn:{current.Apply(getPartitionResult => getPartitionResult.Partition)}:lambda:{currentGetRegion.Apply(getRegionResult => getRegionResult.Region)}:aws:microvm-image:al2023-1";
        }),
        BuildRoleArn = example.Arn,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.AwsFunctions;
import com.pulumi.aws.inputs.GetPartitionArgs;
import com.pulumi.aws.inputs.GetRegionArgs;
import com.pulumi.aws.iam.Role;
import com.pulumi.aws.iam.RoleArgs;
import com.pulumi.aws.s3.Bucket;
import com.pulumi.aws.s3.BucketArgs;
import com.pulumi.aws.iam.RolePolicy;
import com.pulumi.aws.iam.RolePolicyArgs;
import com.pulumi.aws.s3.BucketObjectv2;
import com.pulumi.aws.s3.BucketObjectv2Args;
import com.pulumi.aws.lambdamicrovms.Image;
import com.pulumi.aws.lambdamicrovms.ImageArgs;
import com.pulumi.aws.lambdamicrovms.inputs.ImageCodeArtifactArgs;
import com.pulumi.asset.FileAsset;
import static com.pulumi.codegen.internal.Serialization.*;
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 current = AwsFunctions.getPartition(GetPartitionArgs.builder()
            .build());

        final var currentGetRegion = AwsFunctions.getRegion(GetRegionArgs.builder()
            .build());

        var example = new Role("example", RoleArgs.builder()
            .name("example")
            .assumeRolePolicy(serializeJson(
                jsonObject(
                    jsonProperty("Version", "2012-10-17"),
                    jsonProperty("Statement", jsonArray(jsonObject(
                        jsonProperty("Action", "sts:AssumeRole"),
                        jsonProperty("Effect", "Allow"),
                        jsonProperty("Principal", jsonObject(
                            jsonProperty("Service", "lambda.amazonaws.com")
                        ))
                    )))
                )))
            .build());

        var exampleBucket = new Bucket("exampleBucket", BucketArgs.builder()
            .bucket("example")
            .build());

        var exampleRolePolicy = new RolePolicy("exampleRolePolicy", RolePolicyArgs.builder()
            .name("example")
            .role(example.id())
            .policy(exampleBucket.arn().applyValue(_arn -> serializeJson(
                jsonObject(
                    jsonProperty("Version", "2012-10-17"),
                    jsonProperty("Statement", jsonArray(jsonObject(
                        jsonProperty("Action", jsonArray("s3:GetObject")),
                        jsonProperty("Effect", "Allow"),
                        jsonProperty("Resource", String.format("%s/*", _arn))
                    )))
                ))))
            .build());

        var exampleBucketObjectv2 = new BucketObjectv2("exampleBucketObjectv2", BucketObjectv2Args.builder()
            .bucket(exampleBucket.bucket())
            .key("code.zip")
            .source(new FileAsset("code.zip"))
            .build());

        var exampleImage = new Image("exampleImage", ImageArgs.builder()
            .codeArtifact(ImageCodeArtifactArgs.builder()
                .uri(Output.tuple(exampleBucket.bucket(), exampleBucketObjectv2.key()).applyValue(values -> {
                    var bucket = values.t1;
                    var key = values.t2;
                    return String.format("s3://%s/%s", bucket,key);
                }))
                .build())
            .name("example")
            .baseImageArn(String.format("arn:%s:lambda:%s:aws:microvm-image:al2023-1", current.partition(),currentGetRegion.region()))
            .buildRoleArn(example.arn())
            .build());

    }
}

resources:
  example:
    type: aws:iam:Role
    properties:
      name: example
      assumeRolePolicy:
        fn::toJSON:
          Version: 2012-10-17
          Statement:
            - Action: sts:AssumeRole
              Effect: Allow
              Principal:
                Service: lambda.amazonaws.com
  exampleRolePolicy:
    type: aws:iam:RolePolicy
    name: example
    properties:
      name: example
      role: ${example.id}
      policy:
        fn::toJSON:
          Version: 2012-10-17
          Statement:
            - Action:
                - s3:GetObject
              Effect: Allow
              Resource: ${exampleBucket.arn}/*
  exampleBucket:
    type: aws:s3:Bucket
    name: example
    properties:
      bucket: example
  exampleBucketObjectv2:
    type: aws:s3:BucketObjectv2
    name: example
    properties:
      bucket: ${exampleBucket.bucket}
      key: code.zip
      source:
        fn::fileAsset: code.zip
  exampleImage:
    type: aws:lambdamicrovms:Image
    name: example
    properties:
      codeArtifact:
        uri: s3://${exampleBucket.bucket}/${exampleBucketObjectv2.key}
      name: example
      baseImageArn: arn:${current.partition}:lambda:${currentGetRegion.region}:aws:microvm-image:al2023-1
      buildRoleArn: ${example.arn}
variables:
  current:
    fn::invoke:
      function: aws:getPartition
      arguments: {}
  currentGetRegion:
    fn::invoke:
      function: aws:getRegion
      arguments: {}

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

data "aws_getpartition" "current" {
}
data "aws_getregion" "currentGetRegion" {
}

resource "aws_iam_role" "example" {
  name = "example"
  assume_role_policy = jsonencode({
    "Version" = "2012-10-17"
    "Statement" = [{
      "Action" = "sts:AssumeRole"
      "Effect" = "Allow"
      "Principal" = {
        "Service" = "lambda.amazonaws.com"
      }
    }]
  })
}
resource "aws_iam_rolepolicy" "example" {
  name = "example"
  role = aws_iam_role.example.id
  policy = jsonencode({
    "Version" = "2012-10-17"
    "Statement" = [{
      "Action"   = ["s3:GetObject"]
      "Effect"   = "Allow"
      "Resource" ="${aws_s3_bucket.example.arn}/*"
    }]
  })
}
resource "aws_s3_bucket" "example" {
  bucket = "example"
}
resource "aws_s3_bucketobjectv2" "example" {
  bucket = aws_s3_bucket.example.bucket
  key    = "code.zip"
  source = fileAsset("code.zip")
}
resource "aws_lambdamicrovms_image" "example" {
  code_artifact = {
    uri ="s3://${aws_s3_bucket.example.bucket}/${aws_s3_bucketobjectv2.example.key}"
  }
  name           = "example"
  base_image_arn ="arn:${data.aws_getpartition.current.partition}:lambda:${data.aws_getregion.currentGetRegion.region}:aws:microvm-image:al2023-1"
  build_role_arn = aws_iam_role.example.arn
}

var awsImageResource = new Aws.LambdaMicroVMs.Image("awsImageResource", new()
{
    BuildRoleArn = "string",
    BaseImageArn = "string",
    CodeArtifact = new Aws.LambdaMicroVMs.Inputs.ImageCodeArtifactArgs
    {
        Uri = "string",
    },
    Description = "string",
    BaseImageVersion = "string",
    CpuConfigurations = new[]
    {
        new Aws.LambdaMicroVMs.Inputs.ImageCpuConfigurationArgs
        {
            Architecture = "string",
        },
    },
    AdditionalOsCapabilities = new[]
    {
        "string",
    },
    EgressNetworkConnectors = new[]
    {
        "string",
    },
    EnvironmentVariables = 
    {
        { "string", "string" },
    },
    Name = "string",
    Region = "string",
    Tags = 
    {
        { "string", "string" },
    },
    Timeouts = new Aws.LambdaMicroVMs.Inputs.ImageTimeoutsArgs
    {
        Create = "string",
        Delete = "string",
        Update = "string",
    },
});

example, err := lambdamicrovms.NewImage(ctx, "awsImageResource", &lambdamicrovms.ImageArgs{
	BuildRoleArn: pulumi.String("string"),
	BaseImageArn: pulumi.String("string"),
	CodeArtifact: &lambdamicrovms.ImageCodeArtifactArgs{
		Uri: pulumi.String("string"),
	},
	Description:      pulumi.String("string"),
	BaseImageVersion: pulumi.String("string"),
	CpuConfigurations: lambdamicrovms.ImageCpuConfigurationArray{
		&lambdamicrovms.ImageCpuConfigurationArgs{
			Architecture: pulumi.String("string"),
		},
	},
	AdditionalOsCapabilities: pulumi.StringArray{
		pulumi.String("string"),
	},
	EgressNetworkConnectors: pulumi.StringArray{
		pulumi.String("string"),
	},
	EnvironmentVariables: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Name:   pulumi.String("string"),
	Region: pulumi.String("string"),
	Tags: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Timeouts: &lambdamicrovms.ImageTimeoutsArgs{
		Create: pulumi.String("string"),
		Delete: pulumi.String("string"),
		Update: pulumi.String("string"),
	},
})

resource "aws_lambdamicrovms_image" "awsImageResource" {
  lifecycle {
    create_before_destroy = true
  }
  build_role_arn = "string"
  base_image_arn = "string"
  code_artifact = {
    uri = "string"
  }
  description        = "string"
  base_image_version = "string"
  cpu_configurations {
    architecture = "string"
  }
  additional_os_capabilities = ["string"]
  egress_network_connectors  = ["string"]
  environment_variables = {
    "string" = "string"
  }
  name   = "string"
  region = "string"
  tags = {
    "string" = "string"
  }
  timeouts = {
    create = "string"
    delete = "string"
    update = "string"
  }
}

var awsImageResource = new com.pulumi.aws.lambdamicrovms.Image("awsImageResource", com.pulumi.aws.lambdamicrovms.ImageArgs.builder()
    .buildRoleArn("string")
    .baseImageArn("string")
    .codeArtifact(ImageCodeArtifactArgs.builder()
        .uri("string")
        .build())
    .description("string")
    .baseImageVersion("string")
    .cpuConfigurations(ImageCpuConfigurationArgs.builder()
        .architecture("string")
        .build())
    .additionalOsCapabilities("string")
    .egressNetworkConnectors("string")
    .environmentVariables(Map.of("string", "string"))
    .name("string")
    .region("string")
    .tags(Map.of("string", "string"))
    .timeouts(ImageTimeoutsArgs.builder()
        .create("string")
        .delete("string")
        .update("string")
        .build())
    .build());

aws_image_resource = aws.lambdamicrovms.Image("awsImageResource",
    build_role_arn="string",
    base_image_arn="string",
    code_artifact={
        "uri": "string",
    },
    description="string",
    base_image_version="string",
    cpu_configurations=[{
        "architecture": "string",
    }],
    additional_os_capabilities=["string"],
    egress_network_connectors=["string"],
    environment_variables={
        "string": "string",
    },
    name="string",
    region="string",
    tags={
        "string": "string",
    },
    timeouts={
        "create": "string",
        "delete": "string",
        "update": "string",
    })

const awsImageResource = new aws.lambdamicrovms.Image("awsImageResource", {
    buildRoleArn: "string",
    baseImageArn: "string",
    codeArtifact: {
        uri: "string",
    },
    description: "string",
    baseImageVersion: "string",
    cpuConfigurations: [{
        architecture: "string",
    }],
    additionalOsCapabilities: ["string"],
    egressNetworkConnectors: ["string"],
    environmentVariables: {
        string: "string",
    },
    name: "string",
    region: "string",
    tags: {
        string: "string",
    },
    timeouts: {
        create: "string",
        "delete": "string",
        update: "string",
    },
});

type: aws:lambdamicrovms:Image
properties:
    additionalOsCapabilities:
        - string
    baseImageArn: string
    baseImageVersion: string
    buildRoleArn: string
    codeArtifact:
        uri: string
    cpuConfigurations:
        - architecture: string
    description: string
    egressNetworkConnectors:
        - string
    environmentVariables:
        string: string
    name: string
    region: string
    tags:
        string: string
    timeouts:
        create: string
        delete: string
        update: string