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
Properties
-
addHosts
↔ Output<
List< String> ?> -
Custom
host:ipmappings to use during the build.latefinal -
buildArgs
↔ Output<
Map< String, String> ?> -
ARGnames and values to set during the build.latefinal -
builder
↔ Output<
BuilderConfig?> -
Builder configuration.
latefinal
-
buildOnPreview
↔ Output<
bool?> -
Setting this to
falsewill always skip image builds during previews, and setting it totruewill 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
execmode 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
truethe build will automatically include adockerexport.latefinal -
network
↔ Output<
NetworkMode?> -
Set the network mode for
RUNinstructions. Defaults todefault.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
truethe build will automatically include aregistryexport.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
-
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