getRegistryImage function

Reads the image metadata from a Docker Registry. Used in conjunction with the docker.RemoteImage resource to keep an image up to date on the latest available version of the tag.

Example Usage

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

const ubuntu = docker.getRegistryImage({
    name: "ubuntu:precise",
});
const ubuntuRemoteImage = new docker.RemoteImage("ubuntu", {
    name: ubuntu.then(ubuntu => ubuntu.name),
    pullTriggers: [ubuntu.then(ubuntu => ubuntu.sha256Digest)],
});

import pulumi
import pulumi_docker as docker

ubuntu = docker.get_registry_image(name="ubuntu:precise")
ubuntu_remote_image = docker.RemoteImage("ubuntu",
    name=ubuntu.name,
    pull_triggers=[ubuntu.sha256_digest])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Docker = Pulumi.Docker;

return await Deployment.RunAsync(() =>
{
    var ubuntu = Docker.GetRegistryImage.Invoke(new()
    {
        Name = "ubuntu:precise",
    });

    var ubuntuRemoteImage = new Docker.RemoteImage("ubuntu", new()
    {
        Name = ubuntu.Apply(getRegistryImageResult => getRegistryImageResult.Name),
        PullTriggers = new[]
        {
            ubuntu.Apply(getRegistryImageResult => getRegistryImageResult.Sha256Digest),
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		ubuntu, err := docker.GetRegistryImage(ctx, &docker.LookupRegistryImageArgs{
			Name: "ubuntu:precise",
		}, nil)
		if err != nil {
			return err
		}
		_, err = docker.NewRemoteImage(ctx, "ubuntu", &docker.RemoteImageArgs{
			Name: pulumi.String(ubuntu.Name),
			PullTriggers: pulumi.StringArray{
				pulumi.String(ubuntu.Sha256Digest),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

data "docker_getregistryimage" "ubuntu" {
  name = "ubuntu:precise"
}

resource "docker_remoteimage" "ubuntu" {
  name          = data.docker_getregistryimage.ubuntu.name
  pull_triggers = [data.docker_getregistryimage.ubuntu.sha256_digest]
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.docker.DockerFunctions;
import com.pulumi.docker.inputs.GetRegistryImageArgs;
import com.pulumi.docker.RemoteImage;
import com.pulumi.docker.RemoteImageArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var ubuntu = DockerFunctions.getRegistryImage(GetRegistryImageArgs.builder()
            .name("ubuntu:precise")
            .build());

        var ubuntuRemoteImage = new RemoteImage("ubuntuRemoteImage", RemoteImageArgs.builder()
            .name(ubuntu.name())
            .pullTriggers(ubuntu.sha256Digest())
            .build());

    }
}

resources:
  ubuntuRemoteImage:
    type: docker:RemoteImage
    name: ubuntu
    properties:
      name: ${ubuntu.name}
      pullTriggers:
        - ${ubuntu.sha256Digest}
variables:
  ubuntu:
    fn::invoke:
      function: docker:getRegistryImage
      arguments:
        name: ubuntu:precise

args Arguments passed to this invoke. Arguments for getRegistryImage. options Invoke options controlling this call.