Image class

A Docker image built using buildx -- Docker's interface to the improved BuildKit backend.

Stability

This resource is pre-1.0 and in public preview.

We will strive to keep APIs and behavior as stable as possible, but we cannot guarantee stability until version 1.0.

Migrating Pulumi Docker v3 and v4 Image resources

This provider's Image resource provides a superset of functionality over the Image resources available in versions 3 and 4 of the Pulumi Docker provider. Existing Image resources can be converted to the docker-build Image resources with minor modifications.

Behavioral differences

There are several key behavioral differences to keep in mind when transitioning images to the new Image resource.

Previews

Version 3.x of the Pulumi Docker provider always builds images during preview operations. This is helpful as a safeguard to prevent "broken" images from merging, but users found the behavior unnecessarily redundant when running previews and updates locally.

Version 4.x changed build-on-preview behavior to be opt-in. By default, v4.x Image resources do not build during previews, but this behavior can be toggled with the buildOnPreview option. Several users reported outages due to the default behavior allowing bad images to accidentally sneak through CI.

The default behavior of this provider's Image resource is similar to 3.x and will build images during previews. This behavior can be changed by specifying buildOnPreview.

Push behavior

Versions 3.x and 4.x of the Pulumi Docker provider attempt to push images to remote registries by default. They expose a skipPush: true option to disable pushing.

This provider's Image resource matches the Docker CLI's behavior and does not push images anywhere by default.

To push images to a registry you can include push: true (equivalent to Docker's --push flag) or configure an export of type registry (equivalent to Docker's --output type=registry). Like Docker, if an image is configured without exports you will see a warning with instructions for how to enable pushing, but the build will still proceed normally.

Secrets

Version 3.x of the Pulumi Docker provider supports secrets by way of the extraOptions field.

Version 4.x of the Pulumi Docker provider does not support secrets.

The Image resource supports secrets but does not require those secrets to exist on-disk or in environment variables. Instead, they should be passed directly as values. (Please be sure to familiarize yourself with Pulumi's native secret handling.) Pulumi also provides ESC to make it easier to share secrets across stacks and environments.

Caching

Version 3.x of the Pulumi Docker provider exposes cacheFrom: bool | { stages: [...] }. It builds targets individually and pushes them to separate images for caching.

Version 4.x exposes a similar parameter cacheFrom: { images: [...] } which pushes and pulls inline caches.

Both versions 3 and 4 require specific environment variables to be set and deviate from Docker's native caching behavior. This can result in inefficient builds due to unnecessary image pulls, repeated file transfers, etc.

The Image resource delegates all caching behavior to Docker. cacheFrom and cacheTo options (equivalent to Docker's --cache-to and --cache-from) are exposed and provide additional cache targets, such as local disk, S3 storage, etc.

Outputs

Versions 3.x and 4.x of the provider exposed a repoDigest output which was a fully qualified tag with digest. In 4.x this could also be a single sha256 hash if the image wasn't pushed.

Unlike earlier providers the Image resource can push multiple tags. As a convenience, it exposes a ref output consisting of a tag with digest as long as the image was pushed. If multiple tags were pushed this uses one at random.

If you need more control over tag references you can use the digest output, which is always a single sha256 hash as long as the image was exported somewhere.

Tag deletion and refreshes

Versions 3 and 4 of Pulumi Docker provider do not delete tags when the Image resource is deleted, nor do they confirm expected tags exist during refresh operations.

The buidx.Image will query your registries during refresh to ensure the expected tags exist. If any are missing a subsequent update will push them.

When a Image is deleted, it will attempt to also delete any pushed tags. Deletion of remote tags is not guaranteed because not all registries support the manifest DELETE API (docker.io in particular). Manifests are not deleted in the same way during updates -- to do so safely would require a full build to determine whether a Pulumi operation should be an update or update-replace.

Use the retainOnDelete: true option if you do not want tags deleted.

Example migration

Examples of "fully-featured" v3 and v4 Image resources are shown below, along with an example Image resource showing how they would look after migration.

The v3 resource leverages buildx via a DOCKER_BUILDKIT environment variable and CLI flags passed in with extraOption. After migration, the environment variable is no longer needed and CLI flags are now properties on the Image. In almost all cases, properties of Image are named after the Docker CLI flag they correspond to.

The v4 resource is less functional than its v3 counterpart because it lacks the flexibility of extraOptions. It it is shown with parameters similar to the v3 example for completeness.

{{% examples %}}

Example Usage

{{% example %}}

v3/v4 migration


// v3 Image
const v3 = new docker.Image("v3-image", {
  imageName: "myregistry.com/user/repo:latest",
  localImageName: "local-tag",
  skipPush: false,
  build: {
    dockerfile: "./Dockerfile",
    context: "../app",
    target: "mytarget",
    args: {
      MY_BUILD_ARG: "foo",
    },
    env: {
      DOCKER_BUILDKIT: "1",
    },
    extraOptions: [
      "--cache-from",
      "type=registry,myregistry.com/user/repo:cache",
      "--cache-to",
      "type=registry,myregistry.com/user/repo:cache",
      "--add-host",
      "metadata.google.internal:169.254.169.254",
      "--secret",
      "id=mysecret,src=/local/secret",
      "--ssh",
      "default=/home/runner/.ssh/id_ed25519",
      "--network",
      "host",
      "--platform",
      "linux/amd64",
    ],
  },
  registry: {
    server: "myregistry.com",
    username: "username",
    password: pulumi.secret("password"),
  },
});

// v3 Image after migrating to docker-build.Image
const v3Migrated = new dockerbuild.Image("v3-to-buildx", {
    tags: ["myregistry.com/user/repo:latest", "local-tag"],
    push: true,
    dockerfile: {
        location: "./Dockerfile",
    },
    context: {
        location: "../app",
    },
    target: "mytarget",
    buildArgs: {
        MY_BUILD_ARG: "foo",
    },
    cacheFrom: [{ registry: { ref: "myregistry.com/user/repo:cache" } }],
    cacheTo: [{ registry: { ref: "myregistry.com/user/repo:cache" } }],
    secrets: {
        mysecret: "value",
    },
    addHosts: ["metadata.google.internal:169.254.169.254"],
    ssh: {
        default: ["/home/runner/.ssh/id_ed25519"],
    },
    network: "host",
    platforms: ["linux/amd64"],
    registries: [{
        address: "myregistry.com",
        username: "username",
        password: pulumi.secret("password"),
    }],
});


// v4 Image
const v4 = new docker.Image("v4-image", {
    imageName: "myregistry.com/user/repo:latest",
    skipPush: false,
    build: {
        dockerfile: "./Dockerfile",
        context: "../app",
        target: "mytarget",
        args: {
            MY_BUILD_ARG: "foo",
        },
        cacheFrom: {
            images: ["myregistry.com/user/repo:cache"],
        },
        addHosts: ["metadata.google.internal:169.254.169.254"],
        network: "host",
        platform: "linux/amd64",
    },
    buildOnPreview: true,
    registry: {
        server: "myregistry.com",
        username: "username",
        password: pulumi.secret("password"),
    },
});

// v4 Image after migrating to docker-build.Image
const v4Migrated = new dockerbuild.Image("v4-to-buildx", {
    tags: ["myregistry.com/user/repo:latest"],
    push: true,
    dockerfile: {
        location: "./Dockerfile",
    },
    context: {
        location: "../app",
    },
    target: "mytarget",
    buildArgs: {
        MY_BUILD_ARG: "foo",
    },
    cacheFrom: [{ registry: { ref: "myregistry.com/user/repo:cache" } }],
    cacheTo: [{ registry: { ref: "myregistry.com/user/repo:cache" } }],
    addHosts: ["metadata.google.internal:169.254.169.254"],
    network: "host",
    platforms: ["linux/amd64"],
    registries: [{
        address: "myregistry.com",
        username: "username",
        password: pulumi.secret("password"),
    }],
});

{{% /example %}}

{{% examples %}}

Example Usage

{{% example %}}

Push to AWS ECR with caching

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as docker_build from "@pulumi/docker-build";

const ecrRepository = new aws.ecr.Repository("ecr-repository", {});
const authToken = aws.ecr.getAuthorizationTokenOutput({
    registryId: ecrRepository.registryId,
});
const myImage = new docker_build.Image("my-image", {
    cacheFrom: [{
        registry: {
            ref: pulumi.interpolate`${ecrRepository.repositoryUrl}:cache`,
        },
    }],
    cacheTo: [{
        registry: {
            imageManifest: true,
            ociMediaTypes: true,
            ref: pulumi.interpolate`${ecrRepository.repositoryUrl}:cache`,
        },
    }],
    context: {
        location: "./app",
    },
    push: true,
    registries: [{
        address: ecrRepository.repositoryUrl,
        password: authToken.apply(authToken => authToken.password),
        username: authToken.apply(authToken => authToken.userName),
    }],
    tags: [pulumi.interpolate`${ecrRepository.repositoryUrl}:latest`],
});
export const ref = myImage.ref;
import pulumi
import pulumi_aws as aws
import pulumi_docker_build as docker_build

ecr_repository = aws.ecr.Repository("ecr-repository")
auth_token = aws.ecr.get_authorization_token_output(registry_id=ecr_repository.registry_id)
my_image = docker_build.Image("my-image",
    cache_from=[{
        "registry": {
            "ref": ecr_repository.repository_url.apply(lambda repository_url: f"{repository_url}:cache"),
        },
    }],
    cache_to=[{
        "registry": {
            "image_manifest": True,
            "oci_media_types": True,
            "ref": ecr_repository.repository_url.apply(lambda repository_url: f"{repository_url}:cache"),
        },
    }],
    context={
        "location": "./app",
    },
    push=True,
    registries=[{
        "address": ecr_repository.repository_url,
        "password": auth_token.password,
        "username": auth_token.user_name,
    }],
    tags=[ecr_repository.repository_url.apply(lambda repository_url: f"{repository_url}:latest")])
pulumi.export("ref", my_image.ref)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using DockerBuild = Pulumi.DockerBuild;

return await Deployment.RunAsync(() =>
{
    var ecrRepository = new Aws.Ecr.Repository("ecr-repository");

    var authToken = Aws.Ecr.GetAuthorizationToken.Invoke(new()
    {
        RegistryId = ecrRepository.RegistryId,
    });

    var myImage = new DockerBuild.Image("my-image", new()
    {
        CacheFrom = new[]
        {
            new DockerBuild.Inputs.CacheFromArgs
            {
                Registry = new DockerBuild.Inputs.CacheFromRegistryArgs
                {
                    Ref = ecrRepository.RepositoryUrl.Apply(repositoryUrl => $"{repositoryUrl}:cache"),
                },
            },
        },
        CacheTo = new[]
        {
            new DockerBuild.Inputs.CacheToArgs
            {
                Registry = new DockerBuild.Inputs.CacheToRegistryArgs
                {
                    ImageManifest = true,
                    OciMediaTypes = true,
                    Ref = ecrRepository.RepositoryUrl.Apply(repositoryUrl => $"{repositoryUrl}:cache"),
                },
            },
        },
        Context = new DockerBuild.Inputs.BuildContextArgs
        {
            Location = "./app",
        },
        Push = true,
        Registries = new[]
        {
            new DockerBuild.Inputs.RegistryArgs
            {
                Address = ecrRepository.RepositoryUrl,
                Password = authToken.Apply(getAuthorizationTokenResult => getAuthorizationTokenResult.Password),
                Username = authToken.Apply(getAuthorizationTokenResult => getAuthorizationTokenResult.UserName),
            },
        },
        Tags = new[]
        {
            ecrRepository.RepositoryUrl.Apply(repositoryUrl => $"{repositoryUrl}:latest"),
        },
    });

    return new Dictionary<string, object?>
    {
        ["ref"] = myImage.Ref,
    };
});

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ecr"
	"github.com/pulumi/pulumi-docker-build/sdk/go/dockerbuild"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		ecrRepository, err := ecr.NewRepository(ctx, "ecr-repository", nil)
		if err != nil {
			return err
		}
		authToken := ecr.GetAuthorizationTokenOutput(ctx, ecr.GetAuthorizationTokenOutputArgs{
			RegistryId: ecrRepository.RegistryId,
		}, nil)
		myImage, err := dockerbuild.NewImage(ctx, "my-image", &dockerbuild.ImageArgs{
			CacheFrom: dockerbuild.CacheFromArray{
				&dockerbuild.CacheFromArgs{
					Registry: &dockerbuild.CacheFromRegistryArgs{
						Ref: ecrRepository.RepositoryUrl.ApplyT(func(repositoryUrl string) (string, error) {
							return fmt.Sprintf("%v:cache", repositoryUrl), nil
						}).(pulumi.StringOutput),
					},
				},
			},
			CacheTo: dockerbuild.CacheToArray{
				&dockerbuild.CacheToArgs{
					Registry: &dockerbuild.CacheToRegistryArgs{
						ImageManifest: pulumi.Bool(true),
						OciMediaTypes: pulumi.Bool(true),
						Ref: ecrRepository.RepositoryUrl.ApplyT(func(repositoryUrl string) (string, error) {
							return fmt.Sprintf("%v:cache", repositoryUrl), nil
						}).(pulumi.StringOutput),
					},
				},
			},
			Context: &dockerbuild.BuildContextArgs{
				Location: pulumi.String("./app"),
			},
			Push: pulumi.Bool(true),
			Registries: dockerbuild.RegistryArray{
				&dockerbuild.RegistryArgs{
					Address: ecrRepository.RepositoryUrl,
					Password: authToken.ApplyT(func(authToken ecr.GetAuthorizationTokenResult) (*string, error) {
						return &authToken.Password, nil
					}).(pulumi.StringPtrOutput),
					Username: authToken.ApplyT(func(authToken ecr.GetAuthorizationTokenResult) (*string, error) {
						return &authToken.UserName, nil
					}).(pulumi.StringPtrOutput),
				},
			},
			Tags: pulumi.StringArray{
				ecrRepository.RepositoryUrl.ApplyT(func(repositoryUrl string) (string, error) {
					return fmt.Sprintf("%v:latest", repositoryUrl), nil
				}).(pulumi.StringOutput),
			},
		})
		if err != nil {
			return err
		}
		ctx.Export("ref", myImage.Ref)
		return nil
	})
}
description: Push to AWS ECR with caching
name: ecr
outputs:
    ref: ${my-image.ref}
resources:
    ecr-repository:
        type: aws:ecr:Repository
    my-image:
        properties:
            cacheFrom:
                - registry:
                    ref: ${ecr-repository.repositoryUrl}:cache
            cacheTo:
                - registry:
                    imageManifest: true
                    ociMediaTypes: true
                    ref: ${ecr-repository.repositoryUrl}:cache
            context:
                location: ./app
            push: true
            registries:
                - address: ${ecr-repository.repositoryUrl}
                  password: ${auth-token.password}
                  username: ${auth-token.userName}
            tags:
                - ${ecr-repository.repositoryUrl}:latest
        type: docker-build:Image
runtime: yaml
variables:
    auth-token:
        fn::aws:ecr:getAuthorizationToken:
            registryId: ${ecr-repository.registryId}
pulumi {
  required_providers {
    aws = {
      source  = "pulumi/aws"
      version = "7.29.0"
    }
    docker-build = {
      source  = "pulumi/docker-build"
      version = "0.0.15"
    }
  }
}

data "aws_ecr_getauthorizationtoken" "authToken" {
  registry_id = aws_ecr_repository.ecr-repository.registry_id
}

resource "aws_ecr_repository" "ecr-repository" {
}
resource "docker-build_image" "my-image" {
  cache_from {
    registry = {
      ref ="${aws_ecr_repository.ecr-repository.repository_url}:cache"
    }
  }
  cache_to {
    registry = {
      image_manifest  = true
      oci_media_types = true
      ref             ="${aws_ecr_repository.ecr-repository.repository_url}:cache"
    }
  }
  context = {
    location = "./app"
  }
  push = true
  registries {
    address  = aws_ecr_repository.ecr-repository.repository_url
    password = data.aws_ecr_getauthorizationtoken.authToken.password
    username = data.aws_ecr_getauthorizationtoken.authToken.user_name
  }
  tags = ["${aws_ecr_repository.ecr-repository.repository_url}:latest"]
}
output "ref" {
  value = docker-build_image.my-image.ref
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ecr.Repository;
import com.pulumi.aws.ecr.EcrFunctions;
import com.pulumi.aws.ecr.inputs.GetAuthorizationTokenArgs;
import com.pulumi.dockerbuild.Image;
import com.pulumi.dockerbuild.ImageArgs;
import com.pulumi.dockerbuild.inputs.CacheFromArgs;
import com.pulumi.dockerbuild.inputs.CacheFromRegistryArgs;
import com.pulumi.dockerbuild.inputs.CacheToArgs;
import com.pulumi.dockerbuild.inputs.CacheToRegistryArgs;
import com.pulumi.dockerbuild.inputs.BuildContextArgs;
import com.pulumi.dockerbuild.inputs.RegistryArgs;
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) {
        var ecrRepository = new Repository("ecrRepository");

        final var authToken = EcrFunctions.getAuthorizationToken(GetAuthorizationTokenArgs.builder()
            .registryId(ecrRepository.registryId())
            .build());

        var myImage = new Image("myImage", ImageArgs.builder()
            .cacheFrom(CacheFromArgs.builder()
                .registry(CacheFromRegistryArgs.builder()
                    .ref(ecrRepository.repositoryUrl().applyValue(_repositoryUrl -> String.format("%s:cache", _repositoryUrl)))
                    .build())
                .build())
            .cacheTo(CacheToArgs.builder()
                .registry(CacheToRegistryArgs.builder()
                    .imageManifest(true)
                    .ociMediaTypes(true)
                    .ref(ecrRepository.repositoryUrl().applyValue(_repositoryUrl -> String.format("%s:cache", _repositoryUrl)))
                    .build())
                .build())
            .context(BuildContextArgs.builder()
                .location("./app")
                .build())
            .push(true)
            .registries(RegistryArgs.builder()
                .address(ecrRepository.repositoryUrl())
                .password(authToken.applyValue(_authToken -> _authToken.password()))
                .username(authToken.applyValue(_authToken -> _authToken.userName()))
                .build())
            .tags(ecrRepository.repositoryUrl().applyValue(_repositoryUrl -> String.format("%s:latest", _repositoryUrl)))
            .build());

        ctx.export("ref", myImage.ref());
    }
}

{{% /example %}} {{% example %}}

Multi-platform image

import * as pulumi from "@pulumi/pulumi";
import * as docker_build from "@pulumi/docker-build";

const image = new docker_build.Image("image", {
    context: {
        location: "app",
    },
    platforms: [
        docker_build.Platform.Plan9_amd64,
        docker_build.Platform.Plan9_386,
    ],
    push: false,
});
import pulumi
import pulumi_docker_build as docker_build

image = docker_build.Image("image",
    context={
        "location": "app",
    },
    platforms=[
        docker_build.Platform.PLAN9_AMD64,
        docker_build.Platform.PLAN9_386,
    ],
    push=False)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DockerBuild = Pulumi.DockerBuild;

return await Deployment.RunAsync(() =>
{
    var image = new DockerBuild.Image("image", new()
    {
        Context = new DockerBuild.Inputs.BuildContextArgs
        {
            Location = "app",
        },
        Platforms = new[]
        {
            DockerBuild.Platform.Plan9_amd64,
            DockerBuild.Platform.Plan9_386,
        },
        Push = false,
    });

});

package main

import (
	"github.com/pulumi/pulumi-docker-build/sdk/go/dockerbuild"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dockerbuild.NewImage(ctx, "image", &dockerbuild.ImageArgs{
			Context: &dockerbuild.BuildContextArgs{
				Location: pulumi.String("app"),
			},
			Platforms: docker - build.PlatformArray{
				dockerbuild.Platform_Plan9_amd64,
				dockerbuild.Platform_Plan9_386,
			},
			Push: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
description: Multi-platform image
name: multi-platform
resources:
    image:
        properties:
            context:
                location: app
            platforms:
                - plan9/amd64
                - plan9/386
            push: false
        type: docker-build:Image
runtime: yaml
pulumi {
  required_providers {
    docker-build = {
      source  = "pulumi/docker-build"
      version = "0.0.15"
    }
  }
}

resource "docker-build_image" "image" {
  context = {
    location = "app"
  }
  platforms = ["plan9/amd64", "plan9/386"]
  push      = false
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dockerbuild.Image;
import com.pulumi.dockerbuild.ImageArgs;
import com.pulumi.dockerbuild.inputs.BuildContextArgs;
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) {
        var image = new Image("image", ImageArgs.builder()
            .context(BuildContextArgs.builder()
                .location("app")
                .build())
            .platforms(
                "plan9/amd64",
                "plan9/386")
            .push(false)
            .build());

    }
}

{{% /example %}} {{% example %}}

Registry export

import * as pulumi from "@pulumi/pulumi";
import * as docker_build from "@pulumi/docker-build";

const image = new docker_build.Image("image", {
    context: {
        location: "app",
    },
    push: true,
    registries: [{
        address: "docker.io",
        password: dockerHubPassword,
        username: "pulumibot",
    }],
    tags: ["docker.io/pulumi/pulumi:3.107.0"],
});
export const ref = image.ref;
import pulumi
import pulumi_docker_build as docker_build

image = docker_build.Image("image",
    context={
        "location": "app",
    },
    push=True,
    registries=[{
        "address": "docker.io",
        "password": docker_hub_password,
        "username": "pulumibot",
    }],
    tags=["docker.io/pulumi/pulumi:3.107.0"])
pulumi.export("ref", image.ref)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DockerBuild = Pulumi.DockerBuild;

return await Deployment.RunAsync(() =>
{
    var image = new DockerBuild.Image("image", new()
    {
        Context = new DockerBuild.Inputs.BuildContextArgs
        {
            Location = "app",
        },
        Push = true,
        Registries = new[]
        {
            new DockerBuild.Inputs.RegistryArgs
            {
                Address = "docker.io",
                Password = dockerHubPassword,
                Username = "pulumibot",
            },
        },
        Tags = new[]
        {
            "docker.io/pulumi/pulumi:3.107.0",
        },
    });

    return new Dictionary<string, object?>
    {
        ["ref"] = image.Ref,
    };
});

package main

import (
	"github.com/pulumi/pulumi-docker-build/sdk/go/dockerbuild"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		image, err := dockerbuild.NewImage(ctx, "image", &dockerbuild.ImageArgs{
			Context: &dockerbuild.BuildContextArgs{
				Location: pulumi.String("app"),
			},
			Push: pulumi.Bool(true),
			Registries: dockerbuild.RegistryArray{
				&dockerbuild.RegistryArgs{
					Address:  pulumi.String("docker.io"),
					Password: pulumi.Any(dockerHubPassword),
					Username: pulumi.String("pulumibot"),
				},
			},
			Tags: pulumi.StringArray{
				pulumi.String("docker.io/pulumi/pulumi:3.107.0"),
			},
		})
		if err != nil {
			return err
		}
		ctx.Export("ref", image.Ref)
		return nil
	})
}
description: Registry export
name: registry
outputs:
    ref: ${image.ref}
resources:
    image:
        properties:
            context:
                location: app
            push: true
            registries:
                - address: docker.io
                  password: ${dockerHubPassword}
                  username: pulumibot
            tags:
                - docker.io/pulumi/pulumi:3.107.0
        type: docker-build:Image
runtime: yaml
pulumi {
  required_providers {
    docker-build = {
      source  = "pulumi/docker-build"
      version = "0.0.15"
    }
  }
}

resource "docker-build_image" "image" {
  context = {
    location = "app"
  }
  push = true
  registries {
    address  = "docker.io"
    password = dockerHubPassword
    username = "pulumibot"
  }
  tags = ["docker.io/pulumi/pulumi:3.107.0"]
}
output "ref" {
  value = docker-build_image.image.ref
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dockerbuild.Image;
import com.pulumi.dockerbuild.ImageArgs;
import com.pulumi.dockerbuild.inputs.BuildContextArgs;
import com.pulumi.dockerbuild.inputs.RegistryArgs;
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) {
        var image = new Image("image", ImageArgs.builder()
            .context(BuildContextArgs.builder()
                .location("app")
                .build())
            .push(true)
            .registries(RegistryArgs.builder()
                .address("docker.io")
                .password(dockerHubPassword)
                .username("pulumibot")
                .build())
            .tags("docker.io/pulumi/pulumi:3.107.0")
            .build());

        ctx.export("ref", image.ref());
    }
}

{{% /example %}} {{% example %}}

Caching

import * as pulumi from "@pulumi/pulumi";
import * as docker_build from "@pulumi/docker-build";

const image = new docker_build.Image("image", {
    cacheFrom: [{
        local: {
            src: "tmp/cache",
        },
    }],
    cacheTo: [{
        local: {
            dest: "tmp/cache",
            mode: docker_build.CacheMode.Max,
        },
    }],
    context: {
        location: "app",
    },
    push: false,
});
import pulumi
import pulumi_docker_build as docker_build

image = docker_build.Image("image",
    cache_from=[{
        "local": {
            "src": "tmp/cache",
        },
    }],
    cache_to=[{
        "local": {
            "dest": "tmp/cache",
            "mode": docker_build.CacheMode.MAX,
        },
    }],
    context={
        "location": "app",
    },
    push=False)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DockerBuild = Pulumi.DockerBuild;

return await Deployment.RunAsync(() =>
{
    var image = new DockerBuild.Image("image", new()
    {
        CacheFrom = new[]
        {
            new DockerBuild.Inputs.CacheFromArgs
            {
                Local = new DockerBuild.Inputs.CacheFromLocalArgs
                {
                    Src = "tmp/cache",
                },
            },
        },
        CacheTo = new[]
        {
            new DockerBuild.Inputs.CacheToArgs
            {
                Local = new DockerBuild.Inputs.CacheToLocalArgs
                {
                    Dest = "tmp/cache",
                    Mode = DockerBuild.CacheMode.Max,
                },
            },
        },
        Context = new DockerBuild.Inputs.BuildContextArgs
        {
            Location = "app",
        },
        Push = false,
    });

});

package main

import (
	"github.com/pulumi/pulumi-docker-build/sdk/go/dockerbuild"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dockerbuild.NewImage(ctx, "image", &dockerbuild.ImageArgs{
			CacheFrom: dockerbuild.CacheFromArray{
				&dockerbuild.CacheFromArgs{
					Local: &dockerbuild.CacheFromLocalArgs{
						Src: pulumi.String("tmp/cache"),
					},
				},
			},
			CacheTo: dockerbuild.CacheToArray{
				&dockerbuild.CacheToArgs{
					Local: &dockerbuild.CacheToLocalArgs{
						Dest: pulumi.String("tmp/cache"),
						Mode: dockerbuild.CacheModeMax,
					},
				},
			},
			Context: &dockerbuild.BuildContextArgs{
				Location: pulumi.String("app"),
			},
			Push: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
description: Caching
name: caching
resources:
    image:
        properties:
            cacheFrom:
                - local:
                    src: tmp/cache
            cacheTo:
                - local:
                    dest: tmp/cache
                    mode: max
            context:
                location: app
            push: false
        type: docker-build:Image
runtime: yaml
pulumi {
  required_providers {
    docker-build = {
      source  = "pulumi/docker-build"
      version = "0.0.15"
    }
  }
}

resource "docker-build_image" "image" {
  cache_from {
    local = {
      src = "tmp/cache"
    }
  }
  cache_to {
    local = {
      dest = "tmp/cache"
      mode = "max"
    }
  }
  context = {
    location = "app"
  }
  push = false
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dockerbuild.Image;
import com.pulumi.dockerbuild.ImageArgs;
import com.pulumi.dockerbuild.inputs.CacheFromArgs;
import com.pulumi.dockerbuild.inputs.CacheFromLocalArgs;
import com.pulumi.dockerbuild.inputs.CacheToArgs;
import com.pulumi.dockerbuild.inputs.CacheToLocalArgs;
import com.pulumi.dockerbuild.inputs.BuildContextArgs;
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) {
        var image = new Image("image", ImageArgs.builder()
            .cacheFrom(CacheFromArgs.builder()
                .local(CacheFromLocalArgs.builder()
                    .src("tmp/cache")
                    .build())
                .build())
            .cacheTo(CacheToArgs.builder()
                .local(CacheToLocalArgs.builder()
                    .dest("tmp/cache")
                    .mode("max")
                    .build())
                .build())
            .context(BuildContextArgs.builder()
                .location("app")
                .build())
            .push(false)
            .build());

    }
}

{{% /example %}} {{% example %}}

Docker Build Cloud

import * as pulumi from "@pulumi/pulumi";
import * as docker_build from "@pulumi/docker-build";

const image = new docker_build.Image("image", {
    builder: {
        name: "cloud-builder-name",
    },
    context: {
        location: "app",
    },
    exec: true,
    push: false,
});
import pulumi
import pulumi_docker_build as docker_build

image = docker_build.Image("image",
    builder={
        "name": "cloud-builder-name",
    },
    context={
        "location": "app",
    },
    exec_=True,
    push=False)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DockerBuild = Pulumi.DockerBuild;

return await Deployment.RunAsync(() =>
{
    var image = new DockerBuild.Image("image", new()
    {
        Builder = new DockerBuild.Inputs.BuilderConfigArgs
        {
            Name = "cloud-builder-name",
        },
        Context = new DockerBuild.Inputs.BuildContextArgs
        {
            Location = "app",
        },
        Exec = true,
        Push = false,
    });

});

package main

import (
	"github.com/pulumi/pulumi-docker-build/sdk/go/dockerbuild"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dockerbuild.NewImage(ctx, "image", &dockerbuild.ImageArgs{
			Builder: &dockerbuild.BuilderConfigArgs{
				Name: pulumi.String("cloud-builder-name"),
			},
			Context: &dockerbuild.BuildContextArgs{
				Location: pulumi.String("app"),
			},
			Exec: pulumi.Bool(true),
			Push: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
description: Docker Build Cloud
name: dbc
resources:
    image:
        properties:
            builder:
                name: cloud-builder-name
            context:
                location: app
            exec: true
            push: false
        type: docker-build:Image
runtime: yaml
pulumi {
  required_providers {
    docker-build = {
      source  = "pulumi/docker-build"
      version = "0.0.15"
    }
  }
}

resource "docker-build_image" "image" {
  builder = {
    name = "cloud-builder-name"
  }
  context = {
    location = "app"
  }
  exec = true
  push = false
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dockerbuild.Image;
import com.pulumi.dockerbuild.ImageArgs;
import com.pulumi.dockerbuild.inputs.BuilderConfigArgs;
import com.pulumi.dockerbuild.inputs.BuildContextArgs;
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) {
        var image = new Image("image", ImageArgs.builder()
            .builder(BuilderConfigArgs.builder()
                .name("cloud-builder-name")
                .build())
            .context(BuildContextArgs.builder()
                .location("app")
                .build())
            .exec(true)
            .push(false)
            .build());

    }
}

{{% /example %}} {{% example %}}

Build arguments

import * as pulumi from "@pulumi/pulumi";
import * as docker_build from "@pulumi/docker-build";

const image = new docker_build.Image("image", {
    buildArgs: {
        SET_ME_TO_TRUE: "true",
    },
    context: {
        location: "app",
    },
    push: false,
});
import pulumi
import pulumi_docker_build as docker_build

image = docker_build.Image("image",
    build_args={
        "SET_ME_TO_TRUE": "true",
    },
    context={
        "location": "app",
    },
    push=False)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DockerBuild = Pulumi.DockerBuild;

return await Deployment.RunAsync(() =>
{
    var image = new DockerBuild.Image("image", new()
    {
        BuildArgs =
        {
            { "SET_ME_TO_TRUE", "true" },
        },
        Context = new DockerBuild.Inputs.BuildContextArgs
        {
            Location = "app",
        },
        Push = false,
    });

});

package main

import (
	"github.com/pulumi/pulumi-docker-build/sdk/go/dockerbuild"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dockerbuild.NewImage(ctx, "image", &dockerbuild.ImageArgs{
			BuildArgs: pulumi.StringMap{
				"SET_ME_TO_TRUE": pulumi.String("true"),
			},
			Context: &dockerbuild.BuildContextArgs{
				Location: pulumi.String("app"),
			},
			Push: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
description: Build arguments
name: build-args
resources:
    image:
        properties:
            buildArgs:
                SET_ME_TO_TRUE: "true"
            context:
                location: app
            push: false
        type: docker-build:Image
runtime: yaml
pulumi {
  required_providers {
    docker-build = {
      source  = "pulumi/docker-build"
      version = "0.0.15"
    }
  }
}

resource "docker-build_image" "image" {
  build_args = {
    "SET_ME_TO_TRUE" = "true"
  }
  context = {
    location = "app"
  }
  push = false
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dockerbuild.Image;
import com.pulumi.dockerbuild.ImageArgs;
import com.pulumi.dockerbuild.inputs.BuildContextArgs;
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) {
        var image = new Image("image", ImageArgs.builder()
            .buildArgs(Map.of("SET_ME_TO_TRUE", "true"))
            .context(BuildContextArgs.builder()
                .location("app")
                .build())
            .push(false)
            .build());

    }
}

{{% /example %}} {{% example %}}

Build target

import * as pulumi from "@pulumi/pulumi";
import * as docker_build from "@pulumi/docker-build";

const image = new docker_build.Image("image", {
    context: {
        location: "app",
    },
    push: false,
    target: "build-me",
});
import pulumi
import pulumi_docker_build as docker_build

image = docker_build.Image("image",
    context={
        "location": "app",
    },
    push=False,
    target="build-me")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DockerBuild = Pulumi.DockerBuild;

return await Deployment.RunAsync(() =>
{
    var image = new DockerBuild.Image("image", new()
    {
        Context = new DockerBuild.Inputs.BuildContextArgs
        {
            Location = "app",
        },
        Push = false,
        Target = "build-me",
    });

});

package main

import (
	"github.com/pulumi/pulumi-docker-build/sdk/go/dockerbuild"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dockerbuild.NewImage(ctx, "image", &dockerbuild.ImageArgs{
			Context: &dockerbuild.BuildContextArgs{
				Location: pulumi.String("app"),
			},
			Push:   pulumi.Bool(false),
			Target: pulumi.String("build-me"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
description: Build target
name: build-target
resources:
    image:
        properties:
            context:
                location: app
            push: false
            target: build-me
        type: docker-build:Image
runtime: yaml
pulumi {
  required_providers {
    docker-build = {
      source  = "pulumi/docker-build"
      version = "0.0.15"
    }
  }
}

resource "docker-build_image" "image" {
  context = {
    location = "app"
  }
  push   = false
  target = "build-me"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dockerbuild.Image;
import com.pulumi.dockerbuild.ImageArgs;
import com.pulumi.dockerbuild.inputs.BuildContextArgs;
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) {
        var image = new Image("image", ImageArgs.builder()
            .context(BuildContextArgs.builder()
                .location("app")
                .build())
            .push(false)
            .target("build-me")
            .build());

    }
}

{{% /example %}} {{% example %}}

Named contexts

import * as pulumi from "@pulumi/pulumi";
import * as docker_build from "@pulumi/docker-build";

const image = new docker_build.Image("image", {
    context: {
        location: "app",
        named: {
            "golang:latest": {
                location: "docker-image://golang@sha256:b8e62cf593cdaff36efd90aa3a37de268e6781a2e68c6610940c48f7cdf36984",
            },
        },
    },
    push: false,
});
import pulumi
import pulumi_docker_build as docker_build

image = docker_build.Image("image",
    context={
        "location": "app",
        "named": {
            "golang:latest": {
                "location": "docker-image://golang@sha256:b8e62cf593cdaff36efd90aa3a37de268e6781a2e68c6610940c48f7cdf36984",
            },
        },
    },
    push=False)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DockerBuild = Pulumi.DockerBuild;

return await Deployment.RunAsync(() =>
{
    var image = new DockerBuild.Image("image", new()
    {
        Context = new DockerBuild.Inputs.BuildContextArgs
        {
            Location = "app",
            Named =
            {
                { "golang:latest", new DockerBuild.Inputs.ContextArgs
                {
                    Location = "docker-image://golang@sha256:b8e62cf593cdaff36efd90aa3a37de268e6781a2e68c6610940c48f7cdf36984",
                } },
            },
        },
        Push = false,
    });

});

package main

import (
	"github.com/pulumi/pulumi-docker-build/sdk/go/dockerbuild"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dockerbuild.NewImage(ctx, "image", &dockerbuild.ImageArgs{
			Context: &dockerbuild.BuildContextArgs{
				Location: pulumi.String("app"),
				Named: dockerbuild.ContextMap{
					"golang:latest": &dockerbuild.ContextArgs{
						Location: pulumi.String("docker-image://golang@sha256:b8e62cf593cdaff36efd90aa3a37de268e6781a2e68c6610940c48f7cdf36984"),
					},
				},
			},
			Push: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
description: Named contexts
name: named-contexts
resources:
    image:
        properties:
            context:
                location: app
                named:
                    golang:latest:
                        location: docker-image://golang@sha256:b8e62cf593cdaff36efd90aa3a37de268e6781a2e68c6610940c48f7cdf36984
            push: false
        type: docker-build:Image
runtime: yaml
pulumi {
  required_providers {
    docker-build = {
      source  = "pulumi/docker-build"
      version = "0.0.15"
    }
  }
}

resource "docker-build_image" "image" {
  context = {
    location = "app"
    named = {
      "golang:latest" = {
        location = "docker-image://golang@sha256:b8e62cf593cdaff36efd90aa3a37de268e6781a2e68c6610940c48f7cdf36984"
      }
    }
  }
  push = false
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dockerbuild.Image;
import com.pulumi.dockerbuild.ImageArgs;
import com.pulumi.dockerbuild.inputs.BuildContextArgs;
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) {
        var image = new Image("image", ImageArgs.builder()
            .context(BuildContextArgs.builder()
                .location("app")
                .named(Map.of("golang:latest", ContextArgs.builder()
%!v(PANIC=Format method: interface conversion: model.Expression is *model.TemplateExpression, not *model.LiteralValueExpression)))
                    .build())
                .push(false)
                .build());

        }
}

{{% /example %}} {{% example %}}

Remote context

import * as pulumi from "@pulumi/pulumi";
import * as docker_build from "@pulumi/docker-build";

const image = new docker_build.Image("image", {
    context: {
        location: "https://raw.githubusercontent.com/pulumi/pulumi-docker/api-types/provider/testdata/Dockerfile",
    },
    push: false,
});
import pulumi
import pulumi_docker_build as docker_build

image = docker_build.Image("image",
    context={
        "location": "https://raw.githubusercontent.com/pulumi/pulumi-docker/api-types/provider/testdata/Dockerfile",
    },
    push=False)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DockerBuild = Pulumi.DockerBuild;

return await Deployment.RunAsync(() =>
{
    var image = new DockerBuild.Image("image", new()
    {
        Context = new DockerBuild.Inputs.BuildContextArgs
        {
            Location = "https://raw.githubusercontent.com/pulumi/pulumi-docker/api-types/provider/testdata/Dockerfile",
        },
        Push = false,
    });

});

package main

import (
	"github.com/pulumi/pulumi-docker-build/sdk/go/dockerbuild"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dockerbuild.NewImage(ctx, "image", &dockerbuild.ImageArgs{
			Context: &dockerbuild.BuildContextArgs{
				Location: pulumi.String("https://raw.githubusercontent.com/pulumi/pulumi-docker/api-types/provider/testdata/Dockerfile"),
			},
			Push: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
description: Remote context
name: remote-context
resources:
    image:
        properties:
            context:
                location: https://raw.githubusercontent.com/pulumi/pulumi-docker/api-types/provider/testdata/Dockerfile
            push: false
        type: docker-build:Image
runtime: yaml
pulumi {
  required_providers {
    docker-build = {
      source  = "pulumi/docker-build"
      version = "0.0.15"
    }
  }
}

resource "docker-build_image" "image" {
  context = {
    location = "https://raw.githubusercontent.com/pulumi/pulumi-docker/api-types/provider/testdata/Dockerfile"
  }
  push = false
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dockerbuild.Image;
import com.pulumi.dockerbuild.ImageArgs;
import com.pulumi.dockerbuild.inputs.BuildContextArgs;
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) {
        var image = new Image("image", ImageArgs.builder()
            .context(BuildContextArgs.builder()
                .location("https://raw.githubusercontent.com/pulumi/pulumi-docker/api-types/provider/testdata/Dockerfile")
                .build())
            .push(false)
            .build());

    }
}

{{% /example %}} {{% example %}}

Inline Dockerfile

import * as pulumi from "@pulumi/pulumi";
import * as docker_build from "@pulumi/docker-build";

const image = new docker_build.Image("image", {
    context: {
        location: "app",
    },
    dockerfile: {
        inline: `FROM busybox
COPY hello.c ./
`,
    },
    push: false,
});
import pulumi
import pulumi_docker_build as docker_build

image = docker_build.Image("image",
    context={
        "location": "app",
    },
    dockerfile={
        "inline": """FROM busybox
COPY hello.c ./
""",
    },
    push=False)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DockerBuild = Pulumi.DockerBuild;

return await Deployment.RunAsync(() =>
{
    var image = new DockerBuild.Image("image", new()
    {
        Context = new DockerBuild.Inputs.BuildContextArgs
        {
            Location = "app",
        },
        Dockerfile = new DockerBuild.Inputs.DockerfileArgs
        {
            Inline = @"FROM busybox
COPY hello.c ./
",
        },
        Push = false,
    });

});

package main

import (
	"github.com/pulumi/pulumi-docker-build/sdk/go/dockerbuild"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dockerbuild.NewImage(ctx, "image", &dockerbuild.ImageArgs{
			Context: &dockerbuild.BuildContextArgs{
				Location: pulumi.String("app"),
			},
			Dockerfile: &dockerbuild.DockerfileArgs{
				Inline: pulumi.String("FROM busybox\nCOPY hello.c ./\n"),
			},
			Push: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
description: Inline Dockerfile
name: inline
resources:
    image:
        properties:
            context:
                location: app
            dockerfile:
                inline: |
                    FROM busybox
                    COPY hello.c ./
            push: false
        type: docker-build:Image
runtime: yaml
pulumi {
  required_providers {
    docker-build = {
      source  = "pulumi/docker-build"
      version = "0.0.15"
    }
  }
}

resource "docker-build_image" "image" {
  context = {
    location = "app"
  }
  dockerfile = {
    inline = "FROM busybox\nCOPY hello.c ./\n"
  }
  push = false
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dockerbuild.Image;
import com.pulumi.dockerbuild.ImageArgs;
import com.pulumi.dockerbuild.inputs.BuildContextArgs;
import com.pulumi.dockerbuild.inputs.DockerfileArgs;
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) {
        var image = new Image("image", ImageArgs.builder()
            .context(BuildContextArgs.builder()
                .location("app")
                .build())
            .dockerfile(DockerfileArgs.builder()
                .inline("""
FROM busybox
COPY hello.c ./
                """)
                .build())
            .push(false)
            .build());

    }
}

{{% /example %}} {{% example %}}

Remote context

import * as pulumi from "@pulumi/pulumi";
import * as docker_build from "@pulumi/docker-build";

const image = new docker_build.Image("image", {
    context: {
        location: "https://github.com/docker-library/hello-world.git",
    },
    dockerfile: {
        location: "app/Dockerfile",
    },
    push: false,
});
import pulumi
import pulumi_docker_build as docker_build

image = docker_build.Image("image",
    context={
        "location": "https://github.com/docker-library/hello-world.git",
    },
    dockerfile={
        "location": "app/Dockerfile",
    },
    push=False)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DockerBuild = Pulumi.DockerBuild;

return await Deployment.RunAsync(() =>
{
    var image = new DockerBuild.Image("image", new()
    {
        Context = new DockerBuild.Inputs.BuildContextArgs
        {
            Location = "https://github.com/docker-library/hello-world.git",
        },
        Dockerfile = new DockerBuild.Inputs.DockerfileArgs
        {
            Location = "app/Dockerfile",
        },
        Push = false,
    });

});

package main

import (
	"github.com/pulumi/pulumi-docker-build/sdk/go/dockerbuild"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dockerbuild.NewImage(ctx, "image", &dockerbuild.ImageArgs{
			Context: &dockerbuild.BuildContextArgs{
				Location: pulumi.String("https://github.com/docker-library/hello-world.git"),
			},
			Dockerfile: &dockerbuild.DockerfileArgs{
				Location: pulumi.String("app/Dockerfile"),
			},
			Push: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
description: Remote context
name: remote-context
resources:
    image:
        properties:
            context:
                location: https://github.com/docker-library/hello-world.git
            dockerfile:
                location: app/Dockerfile
            push: false
        type: docker-build:Image
runtime: yaml
pulumi {
  required_providers {
    docker-build = {
      source  = "pulumi/docker-build"
      version = "0.0.15"
    }
  }
}

resource "docker-build_image" "image" {
  context = {
    location = "https://github.com/docker-library/hello-world.git"
  }
  dockerfile = {
    location = "app/Dockerfile"
  }
  push = false
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dockerbuild.Image;
import com.pulumi.dockerbuild.ImageArgs;
import com.pulumi.dockerbuild.inputs.BuildContextArgs;
import com.pulumi.dockerbuild.inputs.DockerfileArgs;
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) {
        var image = new Image("image", ImageArgs.builder()
            .context(BuildContextArgs.builder()
                .location("https://github.com/docker-library/hello-world.git")
                .build())
            .dockerfile(DockerfileArgs.builder()
                .location("app/Dockerfile")
                .build())
            .push(false)
            .build());

    }
}

{{% /example %}} {{% example %}}

Local export

import * as pulumi from "@pulumi/pulumi";
import * as docker_build from "@pulumi/docker-build";

const image = new docker_build.Image("image", {
    context: {
        location: "app",
    },
    exports: [{
        docker: {
            tar: true,
        },
    }],
    push: false,
});
import pulumi
import pulumi_docker_build as docker_build

image = docker_build.Image("image",
    context={
        "location": "app",
    },
    exports=[{
        "docker": {
            "tar": True,
        },
    }],
    push=False)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DockerBuild = Pulumi.DockerBuild;

return await Deployment.RunAsync(() =>
{
    var image = new DockerBuild.Image("image", new()
    {
        Context = new DockerBuild.Inputs.BuildContextArgs
        {
            Location = "app",
        },
        Exports = new[]
        {
            new DockerBuild.Inputs.ExportArgs
            {
                Docker = new DockerBuild.Inputs.ExportDockerArgs
                {
                    Tar = true,
                },
            },
        },
        Push = false,
    });

});

package main

import (
	"github.com/pulumi/pulumi-docker-build/sdk/go/dockerbuild"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dockerbuild.NewImage(ctx, "image", &dockerbuild.ImageArgs{
			Context: &dockerbuild.BuildContextArgs{
				Location: pulumi.String("app"),
			},
			Exports: dockerbuild.ExportArray{
				&dockerbuild.ExportArgs{
					Docker: &dockerbuild.ExportDockerArgs{
						Tar: pulumi.Bool(true),
					},
				},
			},
			Push: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
description: Local export
name: docker-load
resources:
    image:
        properties:
            context:
                location: app
            exports:
                - docker:
                    tar: true
            push: false
        type: docker-build:Image
runtime: yaml
pulumi {
  required_providers {
    docker-build = {
      source  = "pulumi/docker-build"
      version = "0.0.15"
    }
  }
}

resource "docker-build_image" "image" {
  context = {
    location = "app"
  }
  exports {
    docker = {
      tar = true
    }
  }
  push = false
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dockerbuild.Image;
import com.pulumi.dockerbuild.ImageArgs;
import com.pulumi.dockerbuild.inputs.BuildContextArgs;
import com.pulumi.dockerbuild.inputs.ExportArgs;
import com.pulumi.dockerbuild.inputs.ExportDockerArgs;
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) {
        var image = new Image("image", ImageArgs.builder()
            .context(BuildContextArgs.builder()
                .location("app")
                .build())
            .exports(ExportArgs.builder()
                .docker(ExportDockerArgs.builder()
                    .tar(true)
                    .build())
                .build())
            .push(false)
            .build());

    }
}

{{% /example %}} {{% /examples %}}

Constructors

Image(String name, {ImageArgs? args, CustomResourceOptions? options})
Creates a new Image. name The Pulumi resource name. args Arguments used to configure this Image. The set of arguments for Image. options Resource options controlling this resource's behavior.

Properties

addHosts ↔ Output<List<String>?>
Custom host:ip mappings to use during the build.
latefinal
buildArgs ↔ Output<Map<String, String>?>
ARG names and values to set during the build.
latefinal
builder ↔ Output<BuilderConfig?>
Builder configuration.
latefinal
buildOnPreview ↔ Output<bool?>
Setting this to false will always skip image builds during previews, and setting it to true will always build images during previews.
latefinal
cacheFrom ↔ Output<List<Map<String, dynamic>>?>
Cache export configuration.
latefinal
cacheTo ↔ Output<List<Map<String, dynamic>>?>
Cache import configuration.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
context ↔ Output<BuildContext?>
Build context settings. Defaults to the current directory.
latefinal
contextHash ↔ Output<String>
A preliminary hash of the image's build context.
latefinal
digest ↔ Output<String>
A SHA256 digest of the image if it was exported to a registry or elsewhere.
latefinal
dockerfile ↔ Output<Dockerfile?>
Dockerfile settings.
latefinal
exec ↔ Output<bool?>
Use exec mode to build this image.
latefinal
exports ↔ Output<List<Map<String, dynamic>>?>
Controls where images are persisted after building.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
ignoreSecretsInDiffCalculation ↔ Output<List<String>?>
A list of secret names to ignore when calculating diffs.
latefinal
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
labels ↔ Output<Map<String, String>?>
Attach arbitrary key/value metadata to the image.
latefinal
load ↔ Output<bool?>
When true the build will automatically include a docker export.
latefinal
network ↔ Output<NetworkMode?>
Set the network mode for RUN instructions. Defaults to default.
latefinal
noCache ↔ Output<bool?>
Do not import cache manifests when building the image.
latefinal
platforms ↔ Output<List<Platform>?>
Set target platform(s) for the build. Defaults to the host's platform.
latefinal
pull ↔ Output<bool?>
Always pull referenced images.
latefinal
push ↔ Output<bool>
When true the build will automatically include a registry export.
latefinal
ref ↔ Output<String>
If the image was pushed to any registries then this will contain a single fully-qualified tag including the build's digest.
latefinal
registries ↔ Output<List<Map<String, dynamic>>?>
Registry credentials. Required if reading or exporting to private repositories.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
secrets ↔ Output<Map<String, String>?>
A mapping of secret names to their corresponding values.
latefinal
ssh ↔ Output<List<Map<String, dynamic>>?>
SSH agent socket or keys to expose to the build.
latefinal
tags ↔ Output<List<String>?>
Name and optionally a tag (format: name:tag).
latefinal
target ↔ Output<String?>
Set the target build stage(s) to build.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited