4e8cf8f4ba
I could have sworn the context property was required, but evidently it isn't and we weren't handling the case when it was missing. This PR updates things to set a default location of the current directory if the context is absent. Some unit tests are also added. Fixes #78.
1377 lines
49 KiB
Go
Generated
1377 lines
49 KiB
Go
Generated
// Code generated by pulumi-language-go DO NOT EDIT.
|
|
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***
|
|
|
|
package dockerbuild
|
|
|
|
import (
|
|
"context"
|
|
"reflect"
|
|
|
|
"errors"
|
|
"github.com/pulumi/pulumi-docker-build/sdk/go/dockerbuild/internal"
|
|
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
|
|
"github.com/pulumi/pulumi/sdk/v3/go/pulumix"
|
|
)
|
|
|
|
// 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](https://www.pulumi.com/docs/concepts/secrets/).)
|
|
// Pulumi also provides [ESC](https://www.pulumi.com/product/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`](https://www.pulumi.com/docs/concepts/options/retainondelete/) 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.
|
|
//
|
|
// ## Example Usage
|
|
//
|
|
// ## Example Usage
|
|
// ### Push to AWS ECR with caching
|
|
// ```go
|
|
// package main
|
|
//
|
|
// import (
|
|
//
|
|
// "fmt"
|
|
//
|
|
// "github.com/pulumi/pulumi-aws/sdk/v6/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
|
|
// })
|
|
// }
|
|
//
|
|
// ```
|
|
// ### Multi-platform image
|
|
// ```go
|
|
// 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
|
|
// })
|
|
// }
|
|
//
|
|
// ```
|
|
// ### Registry export
|
|
// ```go
|
|
// 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(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", myImage.Ref)
|
|
// return nil
|
|
// })
|
|
// }
|
|
//
|
|
// ```
|
|
// ### Caching
|
|
// ```go
|
|
// 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
|
|
// })
|
|
// }
|
|
//
|
|
// ```
|
|
// ### Docker Build Cloud
|
|
// ```go
|
|
// 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
|
|
// })
|
|
// }
|
|
//
|
|
// ```
|
|
// ### Build arguments
|
|
// ```go
|
|
// 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
|
|
// })
|
|
// }
|
|
//
|
|
// ```
|
|
// ### Build target
|
|
// ```go
|
|
// 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
|
|
// })
|
|
// }
|
|
//
|
|
// ```
|
|
// ### Named contexts
|
|
// ```go
|
|
// 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
|
|
// })
|
|
// }
|
|
//
|
|
// ```
|
|
// ### Remote context
|
|
// ```go
|
|
// 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
|
|
// })
|
|
// }
|
|
//
|
|
// ```
|
|
// ### Inline Dockerfile
|
|
// ```go
|
|
// 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
|
|
// })
|
|
// }
|
|
//
|
|
// ```
|
|
// ### Remote context
|
|
// ```go
|
|
// 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
|
|
// })
|
|
// }
|
|
//
|
|
// ```
|
|
// ### Local export
|
|
// ```go
|
|
// 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
|
|
// })
|
|
// }
|
|
//
|
|
// ```
|
|
type Image struct {
|
|
pulumi.CustomResourceState
|
|
|
|
// Custom `host:ip` mappings to use during the build.
|
|
//
|
|
// Equivalent to Docker's `--add-host` flag.
|
|
AddHosts pulumix.ArrayOutput[string] `pulumi:"addHosts"`
|
|
// `ARG` names and values to set during the build.
|
|
//
|
|
// These variables are accessed like environment variables inside `RUN`
|
|
// instructions.
|
|
//
|
|
// Build arguments are persisted in the image, so you should use `secrets`
|
|
// if these arguments are sensitive.
|
|
//
|
|
// Equivalent to Docker's `--build-arg` flag.
|
|
BuildArgs pulumix.MapOutput[string] `pulumi:"buildArgs"`
|
|
// Setting this to `false` will always skip image builds during previews,
|
|
// and setting it to `true` will always build images during previews.
|
|
//
|
|
// Images built during previews are never exported to registries, however
|
|
// cache manifests are still exported.
|
|
//
|
|
// On-disk Dockerfiles are always validated for syntactic correctness
|
|
// regardless of this setting.
|
|
//
|
|
// Defaults to `true` as a safeguard against broken images merging as part
|
|
// of CI pipelines.
|
|
BuildOnPreview pulumix.Output[*bool] `pulumi:"buildOnPreview"`
|
|
// Builder configuration.
|
|
Builder pulumix.GPtrOutput[BuilderConfig, BuilderConfigOutput] `pulumi:"builder"`
|
|
// Cache export configuration.
|
|
//
|
|
// Equivalent to Docker's `--cache-from` flag.
|
|
CacheFrom pulumix.GArrayOutput[CacheFrom, CacheFromOutput] `pulumi:"cacheFrom"`
|
|
// Cache import configuration.
|
|
//
|
|
// Equivalent to Docker's `--cache-to` flag.
|
|
CacheTo pulumix.GArrayOutput[CacheTo, CacheToOutput] `pulumi:"cacheTo"`
|
|
// Build context settings. Defaults to the current directory.
|
|
//
|
|
// Equivalent to Docker's `PATH | URL | -` positional argument.
|
|
Context pulumix.GPtrOutput[BuildContext, BuildContextOutput] `pulumi:"context"`
|
|
// A preliminary hash of the image's build context.
|
|
//
|
|
// Pulumi uses this to determine if an image _may_ need to be re-built.
|
|
ContextHash pulumix.Output[string] `pulumi:"contextHash"`
|
|
// A SHA256 digest of the image if it was exported to a registry or
|
|
// elsewhere.
|
|
//
|
|
// Empty if the image was not exported.
|
|
//
|
|
// Registry images can be referenced precisely as `<tag>@<digest>`. The
|
|
// `ref` output provides one such reference as a convenience.
|
|
Digest pulumix.Output[string] `pulumi:"digest"`
|
|
// Dockerfile settings.
|
|
//
|
|
// Equivalent to Docker's `--file` flag.
|
|
Dockerfile pulumix.GPtrOutput[Dockerfile, DockerfileOutput] `pulumi:"dockerfile"`
|
|
// Use `exec` mode to build this image.
|
|
//
|
|
// By default the provider embeds a v25 Docker client with v0.12 buildx
|
|
// support. This helps ensure consistent behavior across environments and
|
|
// is compatible with alternative build backends (e.g. `buildkitd`), but
|
|
// it may not be desirable if you require a specific version of buildx.
|
|
// For example you may want to run a custom `docker-buildx` binary with
|
|
// support for [Docker Build
|
|
// Cloud](https://docs.docker.com/build/cloud/setup/) (DBC).
|
|
//
|
|
// When this is set to `true` the provider will instead execute the
|
|
// `docker-buildx` binary directly to perform its operations. The user is
|
|
// responsible for ensuring this binary exists, with correct permissions
|
|
// and pre-configured builders, at a path Docker expects (e.g.
|
|
// `~/.docker/cli-plugins`).
|
|
//
|
|
// Debugging `exec` mode may be more difficult as Pulumi will not be able
|
|
// to surface fine-grained errors and warnings. Additionally credentials
|
|
// are temporarily written to disk in order to provide them to the
|
|
// `docker-buildx` binary.
|
|
Exec pulumix.Output[*bool] `pulumi:"exec"`
|
|
// Controls where images are persisted after building.
|
|
//
|
|
// Images are only stored in the local cache unless `exports` are
|
|
// explicitly configured.
|
|
//
|
|
// Exporting to multiple destinations requires a daemon running BuildKit
|
|
// 0.13 or later.
|
|
//
|
|
// Equivalent to Docker's `--output` flag.
|
|
Exports pulumix.GArrayOutput[Export, ExportOutput] `pulumi:"exports"`
|
|
// Attach arbitrary key/value metadata to the image.
|
|
//
|
|
// Equivalent to Docker's `--label` flag.
|
|
Labels pulumix.MapOutput[string] `pulumi:"labels"`
|
|
// When `true` the build will automatically include a `docker` export.
|
|
//
|
|
// Defaults to `false`.
|
|
//
|
|
// Equivalent to Docker's `--load` flag.
|
|
Load pulumix.Output[*bool] `pulumi:"load"`
|
|
// Set the network mode for `RUN` instructions. Defaults to `default`.
|
|
//
|
|
// For custom networks, configure your builder with `--driver-opt network=...`.
|
|
//
|
|
// Equivalent to Docker's `--network` flag.
|
|
Network pulumix.Output[*NetworkMode] `pulumi:"network"`
|
|
// Do not import cache manifests when building the image.
|
|
//
|
|
// Equivalent to Docker's `--no-cache` flag.
|
|
NoCache pulumix.Output[*bool] `pulumi:"noCache"`
|
|
// Set target platform(s) for the build. Defaults to the host's platform.
|
|
//
|
|
// Equivalent to Docker's `--platform` flag.
|
|
Platforms pulumix.ArrayOutput[Platform] `pulumi:"platforms"`
|
|
// Always pull referenced images.
|
|
//
|
|
// Equivalent to Docker's `--pull` flag.
|
|
Pull pulumix.Output[*bool] `pulumi:"pull"`
|
|
// When `true` the build will automatically include a `registry` export.
|
|
//
|
|
// Defaults to `false`.
|
|
//
|
|
// Equivalent to Docker's `--push` flag.
|
|
Push pulumix.Output[bool] `pulumi:"push"`
|
|
// If the image was pushed to any registries then this will contain a
|
|
// single fully-qualified tag including the build's digest.
|
|
//
|
|
// If the image had tags but was not exported, this will take on a value
|
|
// of one of those tags.
|
|
//
|
|
// This will be empty if the image had no exports and no tags.
|
|
//
|
|
// This is only for convenience and may not be appropriate for situations
|
|
// where multiple tags or registries are involved. In those cases this
|
|
// output is not guaranteed to be stable.
|
|
//
|
|
// For more control over tags consumed by downstream resources you should
|
|
// use the `digest` output.
|
|
Ref pulumix.Output[string] `pulumi:"ref"`
|
|
// Registry credentials. Required if reading or exporting to private
|
|
// repositories.
|
|
//
|
|
// Credentials are kept in-memory and do not pollute pre-existing
|
|
// credentials on the host.
|
|
//
|
|
// Similar to `docker login`.
|
|
Registries pulumix.GArrayOutput[Registry, RegistryOutput] `pulumi:"registries"`
|
|
// A mapping of secret names to their corresponding values.
|
|
//
|
|
// Unlike the Docker CLI, these can be passed by value and do not need to
|
|
// exist on-disk or in environment variables.
|
|
//
|
|
// Build arguments and environment variables are persistent in the final
|
|
// image, so you should use this for sensitive values.
|
|
//
|
|
// Similar to Docker's `--secret` flag.
|
|
Secrets pulumix.MapOutput[string] `pulumi:"secrets"`
|
|
// SSH agent socket or keys to expose to the build.
|
|
//
|
|
// Equivalent to Docker's `--ssh` flag.
|
|
Ssh pulumix.GArrayOutput[SSH, SSHOutput] `pulumi:"ssh"`
|
|
// Name and optionally a tag (format: `name:tag`).
|
|
//
|
|
// If exporting to a registry, the name should include the fully qualified
|
|
// registry address (e.g. `docker.io/pulumi/pulumi:latest`).
|
|
//
|
|
// Equivalent to Docker's `--tag` flag.
|
|
Tags pulumix.ArrayOutput[string] `pulumi:"tags"`
|
|
// Set the target build stage(s) to build.
|
|
//
|
|
// If not specified all targets will be built by default.
|
|
//
|
|
// Equivalent to Docker's `--target` flag.
|
|
Target pulumix.Output[*string] `pulumi:"target"`
|
|
}
|
|
|
|
// NewImage registers a new resource with the given unique name, arguments, and options.
|
|
func NewImage(ctx *pulumi.Context,
|
|
name string, args *ImageArgs, opts ...pulumi.ResourceOption) (*Image, error) {
|
|
if args == nil {
|
|
return nil, errors.New("missing one or more required arguments")
|
|
}
|
|
|
|
if args.Push == nil {
|
|
return nil, errors.New("invalid value for required argument 'Push'")
|
|
}
|
|
if args.BuildOnPreview == nil {
|
|
args.BuildOnPreview = pulumix.Ptr(true)
|
|
}
|
|
if args.Network == nil {
|
|
args.Network = pulumix.Ptr(NetworkMode("default"))
|
|
}
|
|
opts = internal.PkgResourceDefaultOpts(opts)
|
|
var resource Image
|
|
err := ctx.RegisterResource("docker-build:index:Image", name, args, &resource, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &resource, nil
|
|
}
|
|
|
|
// GetImage gets an existing Image resource's state with the given name, ID, and optional
|
|
// state properties that are used to uniquely qualify the lookup (nil if not required).
|
|
func GetImage(ctx *pulumi.Context,
|
|
name string, id pulumi.IDInput, state *ImageState, opts ...pulumi.ResourceOption) (*Image, error) {
|
|
var resource Image
|
|
err := ctx.ReadResource("docker-build:index:Image", name, id, state, &resource, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &resource, nil
|
|
}
|
|
|
|
// Input properties used for looking up and filtering Image resources.
|
|
type imageState struct {
|
|
}
|
|
|
|
type ImageState struct {
|
|
}
|
|
|
|
func (ImageState) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*imageState)(nil)).Elem()
|
|
}
|
|
|
|
type imageArgs struct {
|
|
// Custom `host:ip` mappings to use during the build.
|
|
//
|
|
// Equivalent to Docker's `--add-host` flag.
|
|
AddHosts []string `pulumi:"addHosts"`
|
|
// `ARG` names and values to set during the build.
|
|
//
|
|
// These variables are accessed like environment variables inside `RUN`
|
|
// instructions.
|
|
//
|
|
// Build arguments are persisted in the image, so you should use `secrets`
|
|
// if these arguments are sensitive.
|
|
//
|
|
// Equivalent to Docker's `--build-arg` flag.
|
|
BuildArgs map[string]string `pulumi:"buildArgs"`
|
|
// Setting this to `false` will always skip image builds during previews,
|
|
// and setting it to `true` will always build images during previews.
|
|
//
|
|
// Images built during previews are never exported to registries, however
|
|
// cache manifests are still exported.
|
|
//
|
|
// On-disk Dockerfiles are always validated for syntactic correctness
|
|
// regardless of this setting.
|
|
//
|
|
// Defaults to `true` as a safeguard against broken images merging as part
|
|
// of CI pipelines.
|
|
BuildOnPreview *bool `pulumi:"buildOnPreview"`
|
|
// Builder configuration.
|
|
Builder *BuilderConfig `pulumi:"builder"`
|
|
// Cache export configuration.
|
|
//
|
|
// Equivalent to Docker's `--cache-from` flag.
|
|
CacheFrom []CacheFrom `pulumi:"cacheFrom"`
|
|
// Cache import configuration.
|
|
//
|
|
// Equivalent to Docker's `--cache-to` flag.
|
|
CacheTo []CacheTo `pulumi:"cacheTo"`
|
|
// Build context settings. Defaults to the current directory.
|
|
//
|
|
// Equivalent to Docker's `PATH | URL | -` positional argument.
|
|
Context *BuildContext `pulumi:"context"`
|
|
// Dockerfile settings.
|
|
//
|
|
// Equivalent to Docker's `--file` flag.
|
|
Dockerfile *Dockerfile `pulumi:"dockerfile"`
|
|
// Use `exec` mode to build this image.
|
|
//
|
|
// By default the provider embeds a v25 Docker client with v0.12 buildx
|
|
// support. This helps ensure consistent behavior across environments and
|
|
// is compatible with alternative build backends (e.g. `buildkitd`), but
|
|
// it may not be desirable if you require a specific version of buildx.
|
|
// For example you may want to run a custom `docker-buildx` binary with
|
|
// support for [Docker Build
|
|
// Cloud](https://docs.docker.com/build/cloud/setup/) (DBC).
|
|
//
|
|
// When this is set to `true` the provider will instead execute the
|
|
// `docker-buildx` binary directly to perform its operations. The user is
|
|
// responsible for ensuring this binary exists, with correct permissions
|
|
// and pre-configured builders, at a path Docker expects (e.g.
|
|
// `~/.docker/cli-plugins`).
|
|
//
|
|
// Debugging `exec` mode may be more difficult as Pulumi will not be able
|
|
// to surface fine-grained errors and warnings. Additionally credentials
|
|
// are temporarily written to disk in order to provide them to the
|
|
// `docker-buildx` binary.
|
|
Exec *bool `pulumi:"exec"`
|
|
// Controls where images are persisted after building.
|
|
//
|
|
// Images are only stored in the local cache unless `exports` are
|
|
// explicitly configured.
|
|
//
|
|
// Exporting to multiple destinations requires a daemon running BuildKit
|
|
// 0.13 or later.
|
|
//
|
|
// Equivalent to Docker's `--output` flag.
|
|
Exports []Export `pulumi:"exports"`
|
|
// Attach arbitrary key/value metadata to the image.
|
|
//
|
|
// Equivalent to Docker's `--label` flag.
|
|
Labels map[string]string `pulumi:"labels"`
|
|
// When `true` the build will automatically include a `docker` export.
|
|
//
|
|
// Defaults to `false`.
|
|
//
|
|
// Equivalent to Docker's `--load` flag.
|
|
Load *bool `pulumi:"load"`
|
|
// Set the network mode for `RUN` instructions. Defaults to `default`.
|
|
//
|
|
// For custom networks, configure your builder with `--driver-opt network=...`.
|
|
//
|
|
// Equivalent to Docker's `--network` flag.
|
|
Network *NetworkMode `pulumi:"network"`
|
|
// Do not import cache manifests when building the image.
|
|
//
|
|
// Equivalent to Docker's `--no-cache` flag.
|
|
NoCache *bool `pulumi:"noCache"`
|
|
// Set target platform(s) for the build. Defaults to the host's platform.
|
|
//
|
|
// Equivalent to Docker's `--platform` flag.
|
|
Platforms []Platform `pulumi:"platforms"`
|
|
// Always pull referenced images.
|
|
//
|
|
// Equivalent to Docker's `--pull` flag.
|
|
Pull *bool `pulumi:"pull"`
|
|
// When `true` the build will automatically include a `registry` export.
|
|
//
|
|
// Defaults to `false`.
|
|
//
|
|
// Equivalent to Docker's `--push` flag.
|
|
Push bool `pulumi:"push"`
|
|
// Registry credentials. Required if reading or exporting to private
|
|
// repositories.
|
|
//
|
|
// Credentials are kept in-memory and do not pollute pre-existing
|
|
// credentials on the host.
|
|
//
|
|
// Similar to `docker login`.
|
|
Registries []Registry `pulumi:"registries"`
|
|
// A mapping of secret names to their corresponding values.
|
|
//
|
|
// Unlike the Docker CLI, these can be passed by value and do not need to
|
|
// exist on-disk or in environment variables.
|
|
//
|
|
// Build arguments and environment variables are persistent in the final
|
|
// image, so you should use this for sensitive values.
|
|
//
|
|
// Similar to Docker's `--secret` flag.
|
|
Secrets map[string]string `pulumi:"secrets"`
|
|
// SSH agent socket or keys to expose to the build.
|
|
//
|
|
// Equivalent to Docker's `--ssh` flag.
|
|
Ssh []SSH `pulumi:"ssh"`
|
|
// Name and optionally a tag (format: `name:tag`).
|
|
//
|
|
// If exporting to a registry, the name should include the fully qualified
|
|
// registry address (e.g. `docker.io/pulumi/pulumi:latest`).
|
|
//
|
|
// Equivalent to Docker's `--tag` flag.
|
|
Tags []string `pulumi:"tags"`
|
|
// Set the target build stage(s) to build.
|
|
//
|
|
// If not specified all targets will be built by default.
|
|
//
|
|
// Equivalent to Docker's `--target` flag.
|
|
Target *string `pulumi:"target"`
|
|
}
|
|
|
|
// The set of arguments for constructing a Image resource.
|
|
type ImageArgs struct {
|
|
// Custom `host:ip` mappings to use during the build.
|
|
//
|
|
// Equivalent to Docker's `--add-host` flag.
|
|
AddHosts pulumix.Input[[]string]
|
|
// `ARG` names and values to set during the build.
|
|
//
|
|
// These variables are accessed like environment variables inside `RUN`
|
|
// instructions.
|
|
//
|
|
// Build arguments are persisted in the image, so you should use `secrets`
|
|
// if these arguments are sensitive.
|
|
//
|
|
// Equivalent to Docker's `--build-arg` flag.
|
|
BuildArgs pulumix.Input[map[string]string]
|
|
// Setting this to `false` will always skip image builds during previews,
|
|
// and setting it to `true` will always build images during previews.
|
|
//
|
|
// Images built during previews are never exported to registries, however
|
|
// cache manifests are still exported.
|
|
//
|
|
// On-disk Dockerfiles are always validated for syntactic correctness
|
|
// regardless of this setting.
|
|
//
|
|
// Defaults to `true` as a safeguard against broken images merging as part
|
|
// of CI pipelines.
|
|
BuildOnPreview pulumix.Input[*bool]
|
|
// Builder configuration.
|
|
Builder pulumix.Input[*BuilderConfigArgs]
|
|
// Cache export configuration.
|
|
//
|
|
// Equivalent to Docker's `--cache-from` flag.
|
|
CacheFrom pulumix.Input[[]*CacheFromArgs]
|
|
// Cache import configuration.
|
|
//
|
|
// Equivalent to Docker's `--cache-to` flag.
|
|
CacheTo pulumix.Input[[]*CacheToArgs]
|
|
// Build context settings. Defaults to the current directory.
|
|
//
|
|
// Equivalent to Docker's `PATH | URL | -` positional argument.
|
|
Context pulumix.Input[*BuildContextArgs]
|
|
// Dockerfile settings.
|
|
//
|
|
// Equivalent to Docker's `--file` flag.
|
|
Dockerfile pulumix.Input[*DockerfileArgs]
|
|
// Use `exec` mode to build this image.
|
|
//
|
|
// By default the provider embeds a v25 Docker client with v0.12 buildx
|
|
// support. This helps ensure consistent behavior across environments and
|
|
// is compatible with alternative build backends (e.g. `buildkitd`), but
|
|
// it may not be desirable if you require a specific version of buildx.
|
|
// For example you may want to run a custom `docker-buildx` binary with
|
|
// support for [Docker Build
|
|
// Cloud](https://docs.docker.com/build/cloud/setup/) (DBC).
|
|
//
|
|
// When this is set to `true` the provider will instead execute the
|
|
// `docker-buildx` binary directly to perform its operations. The user is
|
|
// responsible for ensuring this binary exists, with correct permissions
|
|
// and pre-configured builders, at a path Docker expects (e.g.
|
|
// `~/.docker/cli-plugins`).
|
|
//
|
|
// Debugging `exec` mode may be more difficult as Pulumi will not be able
|
|
// to surface fine-grained errors and warnings. Additionally credentials
|
|
// are temporarily written to disk in order to provide them to the
|
|
// `docker-buildx` binary.
|
|
Exec pulumix.Input[*bool]
|
|
// Controls where images are persisted after building.
|
|
//
|
|
// Images are only stored in the local cache unless `exports` are
|
|
// explicitly configured.
|
|
//
|
|
// Exporting to multiple destinations requires a daemon running BuildKit
|
|
// 0.13 or later.
|
|
//
|
|
// Equivalent to Docker's `--output` flag.
|
|
Exports pulumix.Input[[]*ExportArgs]
|
|
// Attach arbitrary key/value metadata to the image.
|
|
//
|
|
// Equivalent to Docker's `--label` flag.
|
|
Labels pulumix.Input[map[string]string]
|
|
// When `true` the build will automatically include a `docker` export.
|
|
//
|
|
// Defaults to `false`.
|
|
//
|
|
// Equivalent to Docker's `--load` flag.
|
|
Load pulumix.Input[*bool]
|
|
// Set the network mode for `RUN` instructions. Defaults to `default`.
|
|
//
|
|
// For custom networks, configure your builder with `--driver-opt network=...`.
|
|
//
|
|
// Equivalent to Docker's `--network` flag.
|
|
Network pulumix.Input[*NetworkMode]
|
|
// Do not import cache manifests when building the image.
|
|
//
|
|
// Equivalent to Docker's `--no-cache` flag.
|
|
NoCache pulumix.Input[*bool]
|
|
// Set target platform(s) for the build. Defaults to the host's platform.
|
|
//
|
|
// Equivalent to Docker's `--platform` flag.
|
|
Platforms pulumix.Input[[]Platform]
|
|
// Always pull referenced images.
|
|
//
|
|
// Equivalent to Docker's `--pull` flag.
|
|
Pull pulumix.Input[*bool]
|
|
// When `true` the build will automatically include a `registry` export.
|
|
//
|
|
// Defaults to `false`.
|
|
//
|
|
// Equivalent to Docker's `--push` flag.
|
|
Push pulumix.Input[bool]
|
|
// Registry credentials. Required if reading or exporting to private
|
|
// repositories.
|
|
//
|
|
// Credentials are kept in-memory and do not pollute pre-existing
|
|
// credentials on the host.
|
|
//
|
|
// Similar to `docker login`.
|
|
Registries pulumix.Input[[]*RegistryArgs]
|
|
// A mapping of secret names to their corresponding values.
|
|
//
|
|
// Unlike the Docker CLI, these can be passed by value and do not need to
|
|
// exist on-disk or in environment variables.
|
|
//
|
|
// Build arguments and environment variables are persistent in the final
|
|
// image, so you should use this for sensitive values.
|
|
//
|
|
// Similar to Docker's `--secret` flag.
|
|
Secrets pulumix.Input[map[string]string]
|
|
// SSH agent socket or keys to expose to the build.
|
|
//
|
|
// Equivalent to Docker's `--ssh` flag.
|
|
Ssh pulumix.Input[[]*SSHArgs]
|
|
// Name and optionally a tag (format: `name:tag`).
|
|
//
|
|
// If exporting to a registry, the name should include the fully qualified
|
|
// registry address (e.g. `docker.io/pulumi/pulumi:latest`).
|
|
//
|
|
// Equivalent to Docker's `--tag` flag.
|
|
Tags pulumix.Input[[]string]
|
|
// Set the target build stage(s) to build.
|
|
//
|
|
// If not specified all targets will be built by default.
|
|
//
|
|
// Equivalent to Docker's `--target` flag.
|
|
Target pulumix.Input[*string]
|
|
}
|
|
|
|
func (ImageArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*imageArgs)(nil)).Elem()
|
|
}
|
|
|
|
type ImageOutput struct{ *pulumi.OutputState }
|
|
|
|
func (ImageOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*Image)(nil)).Elem()
|
|
}
|
|
|
|
func (o ImageOutput) ToImageOutput() ImageOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ImageOutput) ToImageOutputWithContext(ctx context.Context) ImageOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ImageOutput) ToOutput(ctx context.Context) pulumix.Output[Image] {
|
|
return pulumix.Output[Image]{
|
|
OutputState: o.OutputState,
|
|
}
|
|
}
|
|
|
|
// Custom `host:ip` mappings to use during the build.
|
|
//
|
|
// Equivalent to Docker's `--add-host` flag.
|
|
func (o ImageOutput) AddHosts() pulumix.ArrayOutput[string] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.ArrayOutput[string] { return v.AddHosts })
|
|
unwrapped := pulumix.Flatten[[]string, pulumix.ArrayOutput[string]](value)
|
|
return pulumix.ArrayOutput[string]{OutputState: unwrapped.OutputState}
|
|
}
|
|
|
|
// `ARG` names and values to set during the build.
|
|
//
|
|
// These variables are accessed like environment variables inside `RUN`
|
|
// instructions.
|
|
//
|
|
// Build arguments are persisted in the image, so you should use `secrets`
|
|
// if these arguments are sensitive.
|
|
//
|
|
// Equivalent to Docker's `--build-arg` flag.
|
|
func (o ImageOutput) BuildArgs() pulumix.MapOutput[string] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.MapOutput[string] { return v.BuildArgs })
|
|
unwrapped := pulumix.Flatten[map[string]string, pulumix.MapOutput[string]](value)
|
|
return pulumix.MapOutput[string]{OutputState: unwrapped.OutputState}
|
|
}
|
|
|
|
// Setting this to `false` will always skip image builds during previews,
|
|
// and setting it to `true` will always build images during previews.
|
|
//
|
|
// Images built during previews are never exported to registries, however
|
|
// cache manifests are still exported.
|
|
//
|
|
// On-disk Dockerfiles are always validated for syntactic correctness
|
|
// regardless of this setting.
|
|
//
|
|
// Defaults to `true` as a safeguard against broken images merging as part
|
|
// of CI pipelines.
|
|
func (o ImageOutput) BuildOnPreview() pulumix.Output[*bool] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.Output[*bool] { return v.BuildOnPreview })
|
|
return pulumix.Flatten[*bool, pulumix.Output[*bool]](value)
|
|
}
|
|
|
|
// Builder configuration.
|
|
func (o ImageOutput) Builder() pulumix.GPtrOutput[BuilderConfig, BuilderConfigOutput] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.GPtrOutput[BuilderConfig, BuilderConfigOutput] { return v.Builder })
|
|
unwrapped := pulumix.Flatten[*BuilderConfig, pulumix.GPtrOutput[BuilderConfig, BuilderConfigOutput]](value)
|
|
return pulumix.GPtrOutput[BuilderConfig, BuilderConfigOutput]{OutputState: unwrapped.OutputState}
|
|
}
|
|
|
|
// Cache export configuration.
|
|
//
|
|
// Equivalent to Docker's `--cache-from` flag.
|
|
func (o ImageOutput) CacheFrom() pulumix.GArrayOutput[CacheFrom, CacheFromOutput] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.GArrayOutput[CacheFrom, CacheFromOutput] { return v.CacheFrom })
|
|
unwrapped := pulumix.Flatten[[]CacheFrom, pulumix.GArrayOutput[CacheFrom, CacheFromOutput]](value)
|
|
return pulumix.GArrayOutput[CacheFrom, CacheFromOutput]{OutputState: unwrapped.OutputState}
|
|
}
|
|
|
|
// Cache import configuration.
|
|
//
|
|
// Equivalent to Docker's `--cache-to` flag.
|
|
func (o ImageOutput) CacheTo() pulumix.GArrayOutput[CacheTo, CacheToOutput] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.GArrayOutput[CacheTo, CacheToOutput] { return v.CacheTo })
|
|
unwrapped := pulumix.Flatten[[]CacheTo, pulumix.GArrayOutput[CacheTo, CacheToOutput]](value)
|
|
return pulumix.GArrayOutput[CacheTo, CacheToOutput]{OutputState: unwrapped.OutputState}
|
|
}
|
|
|
|
// Build context settings. Defaults to the current directory.
|
|
//
|
|
// Equivalent to Docker's `PATH | URL | -` positional argument.
|
|
func (o ImageOutput) Context() pulumix.GPtrOutput[BuildContext, BuildContextOutput] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.GPtrOutput[BuildContext, BuildContextOutput] { return v.Context })
|
|
unwrapped := pulumix.Flatten[*BuildContext, pulumix.GPtrOutput[BuildContext, BuildContextOutput]](value)
|
|
return pulumix.GPtrOutput[BuildContext, BuildContextOutput]{OutputState: unwrapped.OutputState}
|
|
}
|
|
|
|
// A preliminary hash of the image's build context.
|
|
//
|
|
// Pulumi uses this to determine if an image _may_ need to be re-built.
|
|
func (o ImageOutput) ContextHash() pulumix.Output[string] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.Output[string] { return v.ContextHash })
|
|
return pulumix.Flatten[string, pulumix.Output[string]](value)
|
|
}
|
|
|
|
// A SHA256 digest of the image if it was exported to a registry or
|
|
// elsewhere.
|
|
//
|
|
// Empty if the image was not exported.
|
|
//
|
|
// Registry images can be referenced precisely as `<tag>@<digest>`. The
|
|
// `ref` output provides one such reference as a convenience.
|
|
func (o ImageOutput) Digest() pulumix.Output[string] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.Output[string] { return v.Digest })
|
|
return pulumix.Flatten[string, pulumix.Output[string]](value)
|
|
}
|
|
|
|
// Dockerfile settings.
|
|
//
|
|
// Equivalent to Docker's `--file` flag.
|
|
func (o ImageOutput) Dockerfile() pulumix.GPtrOutput[Dockerfile, DockerfileOutput] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.GPtrOutput[Dockerfile, DockerfileOutput] { return v.Dockerfile })
|
|
unwrapped := pulumix.Flatten[*Dockerfile, pulumix.GPtrOutput[Dockerfile, DockerfileOutput]](value)
|
|
return pulumix.GPtrOutput[Dockerfile, DockerfileOutput]{OutputState: unwrapped.OutputState}
|
|
}
|
|
|
|
// Use `exec` mode to build this image.
|
|
//
|
|
// By default the provider embeds a v25 Docker client with v0.12 buildx
|
|
// support. This helps ensure consistent behavior across environments and
|
|
// is compatible with alternative build backends (e.g. `buildkitd`), but
|
|
// it may not be desirable if you require a specific version of buildx.
|
|
// For example you may want to run a custom `docker-buildx` binary with
|
|
// support for [Docker Build
|
|
// Cloud](https://docs.docker.com/build/cloud/setup/) (DBC).
|
|
//
|
|
// When this is set to `true` the provider will instead execute the
|
|
// `docker-buildx` binary directly to perform its operations. The user is
|
|
// responsible for ensuring this binary exists, with correct permissions
|
|
// and pre-configured builders, at a path Docker expects (e.g.
|
|
// `~/.docker/cli-plugins`).
|
|
//
|
|
// Debugging `exec` mode may be more difficult as Pulumi will not be able
|
|
// to surface fine-grained errors and warnings. Additionally credentials
|
|
// are temporarily written to disk in order to provide them to the
|
|
// `docker-buildx` binary.
|
|
func (o ImageOutput) Exec() pulumix.Output[*bool] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.Output[*bool] { return v.Exec })
|
|
return pulumix.Flatten[*bool, pulumix.Output[*bool]](value)
|
|
}
|
|
|
|
// Controls where images are persisted after building.
|
|
//
|
|
// Images are only stored in the local cache unless `exports` are
|
|
// explicitly configured.
|
|
//
|
|
// Exporting to multiple destinations requires a daemon running BuildKit
|
|
// 0.13 or later.
|
|
//
|
|
// Equivalent to Docker's `--output` flag.
|
|
func (o ImageOutput) Exports() pulumix.GArrayOutput[Export, ExportOutput] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.GArrayOutput[Export, ExportOutput] { return v.Exports })
|
|
unwrapped := pulumix.Flatten[[]Export, pulumix.GArrayOutput[Export, ExportOutput]](value)
|
|
return pulumix.GArrayOutput[Export, ExportOutput]{OutputState: unwrapped.OutputState}
|
|
}
|
|
|
|
// Attach arbitrary key/value metadata to the image.
|
|
//
|
|
// Equivalent to Docker's `--label` flag.
|
|
func (o ImageOutput) Labels() pulumix.MapOutput[string] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.MapOutput[string] { return v.Labels })
|
|
unwrapped := pulumix.Flatten[map[string]string, pulumix.MapOutput[string]](value)
|
|
return pulumix.MapOutput[string]{OutputState: unwrapped.OutputState}
|
|
}
|
|
|
|
// When `true` the build will automatically include a `docker` export.
|
|
//
|
|
// Defaults to `false`.
|
|
//
|
|
// Equivalent to Docker's `--load` flag.
|
|
func (o ImageOutput) Load() pulumix.Output[*bool] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.Output[*bool] { return v.Load })
|
|
return pulumix.Flatten[*bool, pulumix.Output[*bool]](value)
|
|
}
|
|
|
|
// Set the network mode for `RUN` instructions. Defaults to `default`.
|
|
//
|
|
// For custom networks, configure your builder with `--driver-opt network=...`.
|
|
//
|
|
// Equivalent to Docker's `--network` flag.
|
|
func (o ImageOutput) Network() pulumix.Output[*NetworkMode] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.Output[*NetworkMode] { return v.Network })
|
|
return pulumix.Flatten[*NetworkMode, pulumix.Output[*NetworkMode]](value)
|
|
}
|
|
|
|
// Do not import cache manifests when building the image.
|
|
//
|
|
// Equivalent to Docker's `--no-cache` flag.
|
|
func (o ImageOutput) NoCache() pulumix.Output[*bool] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.Output[*bool] { return v.NoCache })
|
|
return pulumix.Flatten[*bool, pulumix.Output[*bool]](value)
|
|
}
|
|
|
|
// Set target platform(s) for the build. Defaults to the host's platform.
|
|
//
|
|
// Equivalent to Docker's `--platform` flag.
|
|
func (o ImageOutput) Platforms() pulumix.ArrayOutput[Platform] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.ArrayOutput[Platform] { return v.Platforms })
|
|
unwrapped := pulumix.Flatten[[]Platform, pulumix.ArrayOutput[Platform]](value)
|
|
return pulumix.ArrayOutput[Platform]{OutputState: unwrapped.OutputState}
|
|
}
|
|
|
|
// Always pull referenced images.
|
|
//
|
|
// Equivalent to Docker's `--pull` flag.
|
|
func (o ImageOutput) Pull() pulumix.Output[*bool] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.Output[*bool] { return v.Pull })
|
|
return pulumix.Flatten[*bool, pulumix.Output[*bool]](value)
|
|
}
|
|
|
|
// When `true` the build will automatically include a `registry` export.
|
|
//
|
|
// Defaults to `false`.
|
|
//
|
|
// Equivalent to Docker's `--push` flag.
|
|
func (o ImageOutput) Push() pulumix.Output[bool] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.Output[bool] { return v.Push })
|
|
return pulumix.Flatten[bool, pulumix.Output[bool]](value)
|
|
}
|
|
|
|
// If the image was pushed to any registries then this will contain a
|
|
// single fully-qualified tag including the build's digest.
|
|
//
|
|
// If the image had tags but was not exported, this will take on a value
|
|
// of one of those tags.
|
|
//
|
|
// This will be empty if the image had no exports and no tags.
|
|
//
|
|
// This is only for convenience and may not be appropriate for situations
|
|
// where multiple tags or registries are involved. In those cases this
|
|
// output is not guaranteed to be stable.
|
|
//
|
|
// For more control over tags consumed by downstream resources you should
|
|
// use the `digest` output.
|
|
func (o ImageOutput) Ref() pulumix.Output[string] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.Output[string] { return v.Ref })
|
|
return pulumix.Flatten[string, pulumix.Output[string]](value)
|
|
}
|
|
|
|
// Registry credentials. Required if reading or exporting to private
|
|
// repositories.
|
|
//
|
|
// Credentials are kept in-memory and do not pollute pre-existing
|
|
// credentials on the host.
|
|
//
|
|
// Similar to `docker login`.
|
|
func (o ImageOutput) Registries() pulumix.GArrayOutput[Registry, RegistryOutput] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.GArrayOutput[Registry, RegistryOutput] { return v.Registries })
|
|
unwrapped := pulumix.Flatten[[]Registry, pulumix.GArrayOutput[Registry, RegistryOutput]](value)
|
|
return pulumix.GArrayOutput[Registry, RegistryOutput]{OutputState: unwrapped.OutputState}
|
|
}
|
|
|
|
// A mapping of secret names to their corresponding values.
|
|
//
|
|
// Unlike the Docker CLI, these can be passed by value and do not need to
|
|
// exist on-disk or in environment variables.
|
|
//
|
|
// Build arguments and environment variables are persistent in the final
|
|
// image, so you should use this for sensitive values.
|
|
//
|
|
// Similar to Docker's `--secret` flag.
|
|
func (o ImageOutput) Secrets() pulumix.MapOutput[string] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.MapOutput[string] { return v.Secrets })
|
|
unwrapped := pulumix.Flatten[map[string]string, pulumix.MapOutput[string]](value)
|
|
return pulumix.MapOutput[string]{OutputState: unwrapped.OutputState}
|
|
}
|
|
|
|
// SSH agent socket or keys to expose to the build.
|
|
//
|
|
// Equivalent to Docker's `--ssh` flag.
|
|
func (o ImageOutput) Ssh() pulumix.GArrayOutput[SSH, SSHOutput] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.GArrayOutput[SSH, SSHOutput] { return v.Ssh })
|
|
unwrapped := pulumix.Flatten[[]SSH, pulumix.GArrayOutput[SSH, SSHOutput]](value)
|
|
return pulumix.GArrayOutput[SSH, SSHOutput]{OutputState: unwrapped.OutputState}
|
|
}
|
|
|
|
// Name and optionally a tag (format: `name:tag`).
|
|
//
|
|
// If exporting to a registry, the name should include the fully qualified
|
|
// registry address (e.g. `docker.io/pulumi/pulumi:latest`).
|
|
//
|
|
// Equivalent to Docker's `--tag` flag.
|
|
func (o ImageOutput) Tags() pulumix.ArrayOutput[string] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.ArrayOutput[string] { return v.Tags })
|
|
unwrapped := pulumix.Flatten[[]string, pulumix.ArrayOutput[string]](value)
|
|
return pulumix.ArrayOutput[string]{OutputState: unwrapped.OutputState}
|
|
}
|
|
|
|
// Set the target build stage(s) to build.
|
|
//
|
|
// If not specified all targets will be built by default.
|
|
//
|
|
// Equivalent to Docker's `--target` flag.
|
|
func (o ImageOutput) Target() pulumix.Output[*string] {
|
|
value := pulumix.Apply[Image](o, func(v Image) pulumix.Output[*string] { return v.Target })
|
|
return pulumix.Flatten[*string, pulumix.Output[*string]](value)
|
|
}
|
|
|
|
func init() {
|
|
pulumi.RegisterOutputType(ImageOutput{})
|
|
}
|