1. Docs
2. Reference
3. API
4. Docker
5. RegistryImage

RegistryImage

Manages the lifecycle of docker image/tag in a registry.

Schema

Required

• name (String) The name of the Docker image.

Optional

• build (Block List, Max: 1) Definition for building the image (see below for nested schema)
• id (String) The ID of this resource.
• insecure_skip_verify (Boolean) If true, the verification of TLS certificates of the server/registry is disabled. Defaults to false
• keep_remotely (Boolean) If true, then the Docker image won’t be deleted on destroy operation. If this is false, it will delete the image from the docker registry on destroy operation. Defaults to false

Read-Only

• sha256_digest (String) The sha256 digest of the image.

Nested Schema for build

Required:

• context (String) The absolute path to the context folder. You can use the helper function ‘${path.cwd}/context-dir’.

Optional:

• auth_config (Block List) The configuration for the authentication (see below for nested schema)
• build_args (Map of String) Pairs for build-time variables in the form TODO
• build_id (String) BuildID is an optional identifier that can be passed together with the build request. The
• cache_from (List of String) Images to consider as cache sources
• cgroup_parent (String) Optional parent cgroup for the container
• cpu_period (Number) The length of a CPU period in microseconds
• cpu_quota (Number) Microseconds of CPU time that the container can get in a CPU period
• cpu_set_cpus (String) CPUs in which to allow execution (e.g., 0-3, 0, 1)
• cpu_set_mems (String) MEMs in which to allow execution (0-3, 0, 1)
• cpu_shares (Number) CPU shares (relative weight)
• dockerfile (String) Dockerfile file. Defaults to Dockerfile
• extra_hosts (List of String) A list of hostnames/IP mappings to add to the container’s /etc/hosts file. Specified in the form [“hostname:IP”]
• force_remove (Boolean) Always remove intermediate containers
• isolation (String) Isolation represents the isolation technology of a container. The supported values are
• labels (Map of String) User-defined key/value metadata
• memory (Number) Set memory limit for build
• memory_swap (Number) Total memory (memory + swap), -1 to enable unlimited swap
• network_mode (String) Set the networking mode for the RUN instructions during build
• no_cache (Boolean) Do not use the cache when building the image
• platform (String) Set platform if server is multi-platform capable
• pull_parent (Boolean) Attempt to pull the image even if an older image exists locally
• remote_context (String) A Git repository URI or HTTP/HTTPS context URI
• remove (Boolean) Remove intermediate containers after a successful build (default behavior)
• security_opt (List of String) The security options
• session_id (String) Set an ID for the build session
• shm_size (Number) Size of /dev/shm in bytes. The size must be greater than 0
• squash (Boolean) If true the new layers are squashed into a new image with a single new layer
• suppress_output (Boolean) Suppress the build output and print image ID on success
• target (String) Set the target build stage to build
• ulimit (Block List) Configuration for ulimits (see below for nested schema)
• version (String) Version of the unerlying builder to use

Nested Schema for build.auth_config

Required:

• host_name (String) hostname of the registry

Optional:

• auth (String) the auth token
• email (String) the user emal
• identity_token (String) the identity token
• password (String) the registry password
• registry_token (String) the registry token
• server_address (String) the server address
• user_name (String) the registry user name

Nested Schema for build.ulimit

Required:

• hard (Number) soft limit
• name (String) type of ulimit, e.g. nofile
• soft (Number) hard limit

using Pulumi;
using Docker = Pulumi.Docker;

class MyStack : Stack
{
    public MyStack()
    {
        var helloworld = new Docker.RegistryImage("helloworld", new Docker.RegistryImageArgs
        {
            Build = new Docker.Inputs.RegistryImageBuildArgs
            {
                Context = $"{path.Cwd}/absolutePathToContextFolder",
            },
        });
    }

}

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-docker/sdk/v3/go/docker"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := docker.NewRegistryImage(ctx, "helloworld", &docker.RegistryImageArgs{
			Build: &docker.RegistryImageBuildArgs{
				Context: pulumi.String(fmt.Sprintf("%v%v", path.Cwd, "/absolutePathToContextFolder")),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import pulumi
import pulumi_docker as docker

helloworld = docker.RegistryImage("helloworld", build=docker.RegistryImageBuildArgs(
    context=f"{path['cwd']}/absolutePathToContextFolder",
))

import * as pulumi from "@pulumi/pulumi";
import * as docker from "@pulumi/docker";
import * as process from "process";

const helloworld = new docker.RegistryImage("helloworld", {
    build: {
        context: `${process.cwd()}/absolutePathToContextFolder`,
    },
});

Create a RegistryImage Resource

new RegistryImage(name: string, args?: RegistryImageArgs, opts?: CustomResourceOptions);

@overload
def RegistryImage(resource_name: str,
                  opts: Optional[ResourceOptions] = None,
                  build: Optional[RegistryImageBuildArgs] = None,
                  insecure_skip_verify: Optional[bool] = None,
                  keep_remotely: Optional[bool] = None,
                  name: Optional[str] = None)
@overload
def RegistryImage(resource_name: str,
                  args: Optional[RegistryImageArgs] = None,
                  opts: Optional[ResourceOptions] = None)

func NewRegistryImage(ctx *Context, name string, args *RegistryImageArgs, opts ...ResourceOption) (*RegistryImage, error)

public RegistryImage(string name, RegistryImageArgs? args = null, CustomResourceOptions? opts = null)

RegistryImage Resource Properties

To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

Inputs

The RegistryImage resource accepts the following input properties:

Outputs

All input properties are implicitly available as output properties. Additionally, the RegistryImage resource produces the following output properties:

Look up an Existing RegistryImage Resource

Get an existing RegistryImage resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

public static get(name: string, id: Input<ID>, state?: RegistryImageState, opts?: CustomResourceOptions): RegistryImage

@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        build: Optional[RegistryImageBuildArgs] = None,
        insecure_skip_verify: Optional[bool] = None,
        keep_remotely: Optional[bool] = None,
        name: Optional[str] = None,
        sha256_digest: Optional[str] = None) -> RegistryImage

func GetRegistryImage(ctx *Context, name string, id IDInput, state *RegistryImageState, opts ...ResourceOption) (*RegistryImage, error)

public static RegistryImage Get(string name, Input<string> id, RegistryImageState? state, CustomResourceOptions? opts = null)

The following state arguments are supported:

Supporting Types

RegistryImageBuild

RegistryImageBuildAuthConfig

RegistryImageBuildUlimit

Package Details

Repository

https://github.com/pulumi/pulumi-docker

License

Apache-2.0

Notes

This Pulumi package is based on the docker Terraform Provider.