pulumi-digitalocean-kotlin/com.pulumi.digitalocean.kotlin/ContainerRegistryDockerCredentials

ContainerRegistryDockerCredentials

class ContainerRegistryDockerCredentials : KotlinCustomResource

Get Docker credentials for your DigitalOcean container registry. An error is triggered if the provided container registry name does not exist.

Example Usage

Basic Example

Get the container registry:

import * as pulumi from "@pulumi/pulumi";
import * as digitalocean from "@pulumi/digitalocean";
const example = new digitalocean.ContainerRegistryDockerCredentials("example", {registryName: "example"});
Content copied to clipboard
import pulumi
import pulumi_digitalocean as digitalocean
example = digitalocean.ContainerRegistryDockerCredentials("example", registry_name="example")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DigitalOcean = Pulumi.DigitalOcean;
return await Deployment.RunAsync(() =>
{
    var example = new DigitalOcean.ContainerRegistryDockerCredentials("example", new()
    {
        RegistryName = "example",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-digitalocean/sdk/v4/go/digitalocean"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := digitalocean.NewContainerRegistryDockerCredentials(ctx, "example", &digitalocean.ContainerRegistryDockerCredentialsArgs{
			RegistryName: pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.digitalocean.ContainerRegistryDockerCredentials;
import com.pulumi.digitalocean.ContainerRegistryDockerCredentialsArgs;
import java.util.List;
import java.util.ArrayList;
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 example = new ContainerRegistryDockerCredentials("example", ContainerRegistryDockerCredentialsArgs.builder()
            .registryName("example")
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: digitalocean:ContainerRegistryDockerCredentials
    properties:
      registryName: example
Content copied to clipboard

Docker Provider Example

Use the endpoint and docker_credentials with the Docker provider:

import * as pulumi from "@pulumi/pulumi";
import * as digitalocean from "@pulumi/digitalocean";
const example = digitalocean.getContainerRegistry({
    name: "example",
});
const exampleContainerRegistryDockerCredentials = new digitalocean.ContainerRegistryDockerCredentials("example", {registryName: "example"});
Content copied to clipboard
import pulumi
import pulumi_digitalocean as digitalocean
example = digitalocean.get_container_registry(name="example")
example_container_registry_docker_credentials = digitalocean.ContainerRegistryDockerCredentials("example", registry_name="example")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DigitalOcean = Pulumi.DigitalOcean;
return await Deployment.RunAsync(() =>
{
    var example = DigitalOcean.GetContainerRegistry.Invoke(new()
    {
        Name = "example",
    });
    var exampleContainerRegistryDockerCredentials = new DigitalOcean.ContainerRegistryDockerCredentials("example", new()
    {
        RegistryName = "example",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-digitalocean/sdk/v4/go/digitalocean"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := digitalocean.LookupContainerRegistry(ctx, &digitalocean.LookupContainerRegistryArgs{
			Name: "example",
		}, nil)
		if err != nil {
			return err
		}
		_, err = digitalocean.NewContainerRegistryDockerCredentials(ctx, "example", &digitalocean.ContainerRegistryDockerCredentialsArgs{
			RegistryName: pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.digitalocean.DigitaloceanFunctions;
import com.pulumi.digitalocean.inputs.GetContainerRegistryArgs;
import com.pulumi.digitalocean.ContainerRegistryDockerCredentials;
import com.pulumi.digitalocean.ContainerRegistryDockerCredentialsArgs;
import java.util.List;
import java.util.ArrayList;
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 example = DigitaloceanFunctions.getContainerRegistry(GetContainerRegistryArgs.builder()
            .name("example")
            .build());
        var exampleContainerRegistryDockerCredentials = new ContainerRegistryDockerCredentials("exampleContainerRegistryDockerCredentials", ContainerRegistryDockerCredentialsArgs.builder()
            .registryName("example")
            .build());
    }
}
Content copied to clipboard
resources:
  exampleContainerRegistryDockerCredentials:
    type: digitalocean:ContainerRegistryDockerCredentials
    name: example
    properties:
      registryName: example
variables:
  example:
    fn::invoke:
      function: digitalocean:getContainerRegistry
      arguments:
        name: example
Content copied to clipboard

Kubernetes Example

Combined with the Kubernetes Provider's kubernetes_secret resource, you can access the registry from inside your cluster:

import * as pulumi from "@pulumi/pulumi";
import * as digitalocean from "@pulumi/digitalocean";
import * as kubernetes from "@pulumi/kubernetes";
const exampleContainerRegistryDockerCredentials = new digitalocean.ContainerRegistryDockerCredentials("example", {registryName: "example"});
const example = digitalocean.getKubernetesCluster({
    name: "prod-cluster-01",
});
const exampleSecret = new kubernetes.core.v1.Secret("example", {
    metadata: {
        name: "docker-cfg",
    },
    data: {
        ".dockerconfigjson": exampleContainerRegistryDockerCredentials.dockerCredentials,
    },
    type: "kubernetes.io/dockerconfigjson",
});
Content copied to clipboard
import pulumi
import pulumi_digitalocean as digitalocean
import pulumi_kubernetes as kubernetes
example_container_registry_docker_credentials = digitalocean.ContainerRegistryDockerCredentials("example", registry_name="example")
example = digitalocean.get_kubernetes_cluster(name="prod-cluster-01")
example_secret = kubernetes.core.v1.Secret("example",
    metadata={
        "name": "docker-cfg",
    },
    data={
        ".dockerconfigjson": example_container_registry_docker_credentials.docker_credentials,
    },
    type="kubernetes.io/dockerconfigjson")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DigitalOcean = Pulumi.DigitalOcean;
using Kubernetes = Pulumi.Kubernetes;
return await Deployment.RunAsync(() =>
{
    var exampleContainerRegistryDockerCredentials = new DigitalOcean.ContainerRegistryDockerCredentials("example", new()
    {
        RegistryName = "example",
    });
    var example = DigitalOcean.GetKubernetesCluster.Invoke(new()
    {
        Name = "prod-cluster-01",
    });
    var exampleSecret = new Kubernetes.Core.V1.Secret("example", new()
    {
        Metadata = new Kubernetes.Types.Inputs.Meta.V1.ObjectMetaArgs
        {
            Name = "docker-cfg",
        },
        Data =
        {
            { ".dockerconfigjson", exampleContainerRegistryDockerCredentials.DockerCredentials },
        },
        Type = "kubernetes.io/dockerconfigjson",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-digitalocean/sdk/v4/go/digitalocean"
	corev1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/core/v1"
	metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleContainerRegistryDockerCredentials, err := digitalocean.NewContainerRegistryDockerCredentials(ctx, "example", &digitalocean.ContainerRegistryDockerCredentialsArgs{
			RegistryName: pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		_, err = digitalocean.LookupKubernetesCluster(ctx, &digitalocean.LookupKubernetesClusterArgs{
			Name: "prod-cluster-01",
		}, nil)
		if err != nil {
			return err
		}
		_, err = corev1.NewSecret(ctx, "example", &corev1.SecretArgs{
			Metadata: &metav1.ObjectMetaArgs{
				Name: pulumi.String("docker-cfg"),
			},
			Data: pulumi.StringMap{
				".dockerconfigjson": exampleContainerRegistryDockerCredentials.DockerCredentials,
			},
			Type: pulumi.String("kubernetes.io/dockerconfigjson"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.digitalocean.ContainerRegistryDockerCredentials;
import com.pulumi.digitalocean.ContainerRegistryDockerCredentialsArgs;
import com.pulumi.digitalocean.DigitaloceanFunctions;
import com.pulumi.digitalocean.inputs.GetKubernetesClusterArgs;
import com.pulumi.kubernetes.core_v1.Secret;
import com.pulumi.kubernetes.core_v1.SecretArgs;
import com.pulumi.kubernetes.meta_v1.inputs.ObjectMetaArgs;
import java.util.List;
import java.util.ArrayList;
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 exampleContainerRegistryDockerCredentials = new ContainerRegistryDockerCredentials("exampleContainerRegistryDockerCredentials", ContainerRegistryDockerCredentialsArgs.builder()
            .registryName("example")
            .build());
        final var example = DigitaloceanFunctions.getKubernetesCluster(GetKubernetesClusterArgs.builder()
            .name("prod-cluster-01")
            .build());
        var exampleSecret = new Secret("exampleSecret", SecretArgs.builder()
            .metadata(ObjectMetaArgs.builder()
                .name("docker-cfg")
                .build())
            .data(Map.of(".dockerconfigjson", exampleContainerRegistryDockerCredentials.dockerCredentials()))
            .type("kubernetes.io/dockerconfigjson")
            .build());
    }
}
Content copied to clipboard
resources:
  exampleContainerRegistryDockerCredentials:
    type: digitalocean:ContainerRegistryDockerCredentials
    name: example
    properties:
      registryName: example
  exampleSecret:
    type: kubernetes:core/v1:Secret
    name: example
    properties:
      metadata:
        name: docker-cfg
      data:
        .dockerconfigjson: ${exampleContainerRegistryDockerCredentials.dockerCredentials}
      type: kubernetes.io/dockerconfigjson
variables:
  example:
    fn::invoke:
      function: digitalocean:getKubernetesCluster
      arguments:
        name: prod-cluster-01
Content copied to clipboard

Properties

Link copied to clipboard
val credentialExpirationTime: Output<String>

The date and time the registry access token will expire.

Link copied to clipboard
val dockerCredentials: Output<String>

Credentials for the container registry.

Link copied to clipboard
val expirySeconds: Output<Int>?

The amount of time to pass before the Docker credentials expire in seconds. Defaults to 1576800000, or roughly 50 years. Must be greater than 0 and less than 1576800000.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val registryName: Output<String>

The name of the container registry.

Link copied to clipboard
val urn: Output<String>
Link copied to clipboard
val write: Output<Boolean>?

Allow for write access to the container registry. Defaults to false.