gcp.artifactregistry.Repository

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

const my_repo = new gcp.artifactregistry.Repository("my-repo", {
    location: "us-central1",
    repositoryId: "my-repository",
    description: "example docker repository",
    format: "DOCKER",
});

import pulumi
import pulumi_gcp as gcp

my_repo = gcp.artifactregistry.Repository("my-repo",
    location="us-central1",
    repository_id="my-repository",
    description="example docker repository",
    format="DOCKER")

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/artifactregistry"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := artifactregistry.NewRepository(ctx, "my-repo", &artifactregistry.RepositoryArgs{
			Location:     pulumi.String("us-central1"),
			RepositoryId: pulumi.String("my-repository"),
			Description:  pulumi.String("example docker repository"),
			Format:       pulumi.String("DOCKER"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var my_repo = new Gcp.ArtifactRegistry.Repository("my-repo", new()
    {
        Location = "us-central1",
        RepositoryId = "my-repository",
        Description = "example docker repository",
        Format = "DOCKER",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.artifactregistry.Repository;
import com.pulumi.gcp.artifactregistry.RepositoryArgs;
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 my_repo = new Repository("my-repo", RepositoryArgs.builder()        
            .location("us-central1")
            .repositoryId("my-repository")
            .description("example docker repository")
            .format("DOCKER")
            .build());

    }
}

resources:
  my-repo:
    type: gcp:artifactregistry:Repository
    properties:
      location: us-central1
      repositoryId: my-repository
      description: example docker repository
      format: DOCKER

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

const my_repo = new gcp.artifactregistry.Repository("my-repo", {
    location: "us-central1",
    repositoryId: "my-repository",
    description: "example docker repository",
    format: "DOCKER",
    dockerConfig: {
        immutableTags: true,
    },
});

import pulumi
import pulumi_gcp as gcp

my_repo = gcp.artifactregistry.Repository("my-repo",
    location="us-central1",
    repository_id="my-repository",
    description="example docker repository",
    format="DOCKER",
    docker_config=gcp.artifactregistry.RepositoryDockerConfigArgs(
        immutable_tags=True,
    ))

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/artifactregistry"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := artifactregistry.NewRepository(ctx, "my-repo", &artifactregistry.RepositoryArgs{
			Location:     pulumi.String("us-central1"),
			RepositoryId: pulumi.String("my-repository"),
			Description:  pulumi.String("example docker repository"),
			Format:       pulumi.String("DOCKER"),
			DockerConfig: &artifactregistry.RepositoryDockerConfigArgs{
				ImmutableTags: pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var my_repo = new Gcp.ArtifactRegistry.Repository("my-repo", new()
    {
        Location = "us-central1",
        RepositoryId = "my-repository",
        Description = "example docker repository",
        Format = "DOCKER",
        DockerConfig = new Gcp.ArtifactRegistry.Inputs.RepositoryDockerConfigArgs
        {
            ImmutableTags = true,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.artifactregistry.Repository;
import com.pulumi.gcp.artifactregistry.RepositoryArgs;
import com.pulumi.gcp.artifactregistry.inputs.RepositoryDockerConfigArgs;
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 my_repo = new Repository("my-repo", RepositoryArgs.builder()        
            .location("us-central1")
            .repositoryId("my-repository")
            .description("example docker repository")
            .format("DOCKER")
            .dockerConfig(RepositoryDockerConfigArgs.builder()
                .immutableTags(true)
                .build())
            .build());

    }
}

resources:
  my-repo:
    type: gcp:artifactregistry:Repository
    properties:
      location: us-central1
      repositoryId: my-repository
      description: example docker repository
      format: DOCKER
      dockerConfig:
        immutableTags: true

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

const my_repo = new gcp.artifactregistry.Repository("my-repo", {
    location: "us-central1",
    repositoryId: "my-repository",
    description: "example docker repository with cmek",
    format: "DOCKER",
    kmsKeyName: "kms-key",
});
const project = gcp.organizations.getProject({});
const cryptoKey = new gcp.kms.CryptoKeyIAMMember("crypto_key", {
    cryptoKeyId: "kms-key",
    role: "roles/cloudkms.cryptoKeyEncrypterDecrypter",
    member: project.then(project => `serviceAccount:service-${project.number}@gcp-sa-artifactregistry.iam.gserviceaccount.com`),
});

import pulumi
import pulumi_gcp as gcp

my_repo = gcp.artifactregistry.Repository("my-repo",
    location="us-central1",
    repository_id="my-repository",
    description="example docker repository with cmek",
    format="DOCKER",
    kms_key_name="kms-key")
project = gcp.organizations.get_project()
crypto_key = gcp.kms.CryptoKeyIAMMember("crypto_key",
    crypto_key_id="kms-key",
    role="roles/cloudkms.cryptoKeyEncrypterDecrypter",
    member=f"serviceAccount:service-{project.number}@gcp-sa-artifactregistry.iam.gserviceaccount.com")

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/artifactregistry"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/kms"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := artifactregistry.NewRepository(ctx, "my-repo", &artifactregistry.RepositoryArgs{
			Location:     pulumi.String("us-central1"),
			RepositoryId: pulumi.String("my-repository"),
			Description:  pulumi.String("example docker repository with cmek"),
			Format:       pulumi.String("DOCKER"),
			KmsKeyName:   pulumi.String("kms-key"),
		})
		if err != nil {
			return err
		}
		project, err := organizations.LookupProject(ctx, nil, nil)
		if err != nil {
			return err
		}
		_, err = kms.NewCryptoKeyIAMMember(ctx, "crypto_key", &kms.CryptoKeyIAMMemberArgs{
			CryptoKeyId: pulumi.String("kms-key"),
			Role:        pulumi.String("roles/cloudkms.cryptoKeyEncrypterDecrypter"),
			Member:      pulumi.String(fmt.Sprintf("serviceAccount:service-%v@gcp-sa-artifactregistry.iam.gserviceaccount.com", project.Number)),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var my_repo = new Gcp.ArtifactRegistry.Repository("my-repo", new()
    {
        Location = "us-central1",
        RepositoryId = "my-repository",
        Description = "example docker repository with cmek",
        Format = "DOCKER",
        KmsKeyName = "kms-key",
    });

    var project = Gcp.Organizations.GetProject.Invoke();

    var cryptoKey = new Gcp.Kms.CryptoKeyIAMMember("crypto_key", new()
    {
        CryptoKeyId = "kms-key",
        Role = "roles/cloudkms.cryptoKeyEncrypterDecrypter",
        Member = $"serviceAccount:service-{project.Apply(getProjectResult => getProjectResult.Number)}@gcp-sa-artifactregistry.iam.gserviceaccount.com",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.artifactregistry.Repository;
import com.pulumi.gcp.artifactregistry.RepositoryArgs;
import com.pulumi.gcp.organizations.OrganizationsFunctions;
import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
import com.pulumi.gcp.kms.CryptoKeyIAMMember;
import com.pulumi.gcp.kms.CryptoKeyIAMMemberArgs;
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 my_repo = new Repository("my-repo", RepositoryArgs.builder()        
            .location("us-central1")
            .repositoryId("my-repository")
            .description("example docker repository with cmek")
            .format("DOCKER")
            .kmsKeyName("kms-key")
            .build());

        final var project = OrganizationsFunctions.getProject();

        var cryptoKey = new CryptoKeyIAMMember("cryptoKey", CryptoKeyIAMMemberArgs.builder()        
            .cryptoKeyId("kms-key")
            .role("roles/cloudkms.cryptoKeyEncrypterDecrypter")
            .member(String.format("serviceAccount:service-%s@gcp-sa-artifactregistry.iam.gserviceaccount.com", project.applyValue(getProjectResult -> getProjectResult.number())))
            .build());

    }
}

resources:
  my-repo:
    type: gcp:artifactregistry:Repository
    properties:
      location: us-central1
      repositoryId: my-repository
      description: example docker repository with cmek
      format: DOCKER
      kmsKeyName: kms-key
  cryptoKey:
    type: gcp:kms:CryptoKeyIAMMember
    name: crypto_key
    properties:
      cryptoKeyId: kms-key
      role: roles/cloudkms.cryptoKeyEncrypterDecrypter
      member: serviceAccount:service-${project.number}@gcp-sa-artifactregistry.iam.gserviceaccount.com
variables:
  project:
    fn::invoke:
      Function: gcp:organizations:getProject
      Arguments: {}

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

const my_repo_upstream_1 = new gcp.artifactregistry.Repository("my-repo-upstream-1", {
    location: "us-central1",
    repositoryId: "my-repository-upstream-1",
    description: "example docker repository (upstream source) 1",
    format: "DOCKER",
});
const my_repo_upstream_2 = new gcp.artifactregistry.Repository("my-repo-upstream-2", {
    location: "us-central1",
    repositoryId: "my-repository-upstream-2",
    description: "example docker repository (upstream source) 2",
    format: "DOCKER",
});
const my_repo = new gcp.artifactregistry.Repository("my-repo", {
    location: "us-central1",
    repositoryId: "my-repository",
    description: "example virtual docker repository",
    format: "DOCKER",
    mode: "VIRTUAL_REPOSITORY",
    virtualRepositoryConfig: {
        upstreamPolicies: [
            {
                id: "my-repository-upstream-1",
                repository: my_repo_upstream_1.id,
                priority: 20,
            },
            {
                id: "my-repository-upstream-2",
                repository: my_repo_upstream_2.id,
                priority: 10,
            },
        ],
    },
});

import pulumi
import pulumi_gcp as gcp

my_repo_upstream_1 = gcp.artifactregistry.Repository("my-repo-upstream-1",
    location="us-central1",
    repository_id="my-repository-upstream-1",
    description="example docker repository (upstream source) 1",
    format="DOCKER")
my_repo_upstream_2 = gcp.artifactregistry.Repository("my-repo-upstream-2",
    location="us-central1",
    repository_id="my-repository-upstream-2",
    description="example docker repository (upstream source) 2",
    format="DOCKER")
my_repo = gcp.artifactregistry.Repository("my-repo",
    location="us-central1",
    repository_id="my-repository",
    description="example virtual docker repository",
    format="DOCKER",
    mode="VIRTUAL_REPOSITORY",
    virtual_repository_config=gcp.artifactregistry.RepositoryVirtualRepositoryConfigArgs(
        upstream_policies=[
            gcp.artifactregistry.RepositoryVirtualRepositoryConfigUpstreamPolicyArgs(
                id="my-repository-upstream-1",
                repository=my_repo_upstream_1.id,
                priority=20,
            ),
            gcp.artifactregistry.RepositoryVirtualRepositoryConfigUpstreamPolicyArgs(
                id="my-repository-upstream-2",
                repository=my_repo_upstream_2.id,
                priority=10,
            ),
        ],
    ))

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/artifactregistry"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := artifactregistry.NewRepository(ctx, "my-repo-upstream-1", &artifactregistry.RepositoryArgs{
			Location:     pulumi.String("us-central1"),
			RepositoryId: pulumi.String("my-repository-upstream-1"),
			Description:  pulumi.String("example docker repository (upstream source) 1"),
			Format:       pulumi.String("DOCKER"),
		})
		if err != nil {
			return err
		}
		_, err = artifactregistry.NewRepository(ctx, "my-repo-upstream-2", &artifactregistry.RepositoryArgs{
			Location:     pulumi.String("us-central1"),
			RepositoryId: pulumi.String("my-repository-upstream-2"),
			Description:  pulumi.String("example docker repository (upstream source) 2"),
			Format:       pulumi.String("DOCKER"),
		})
		if err != nil {
			return err
		}
		_, err = artifactregistry.NewRepository(ctx, "my-repo", &artifactregistry.RepositoryArgs{
			Location:     pulumi.String("us-central1"),
			RepositoryId: pulumi.String("my-repository"),
			Description:  pulumi.String("example virtual docker repository"),
			Format:       pulumi.String("DOCKER"),
			Mode:         pulumi.String("VIRTUAL_REPOSITORY"),
			VirtualRepositoryConfig: &artifactregistry.RepositoryVirtualRepositoryConfigArgs{
				UpstreamPolicies: artifactregistry.RepositoryVirtualRepositoryConfigUpstreamPolicyArray{
					&artifactregistry.RepositoryVirtualRepositoryConfigUpstreamPolicyArgs{
						Id:         pulumi.String("my-repository-upstream-1"),
						Repository: my_repo_upstream_1.ID(),
						Priority:   pulumi.Int(20),
					},
					&artifactregistry.RepositoryVirtualRepositoryConfigUpstreamPolicyArgs{
						Id:         pulumi.String("my-repository-upstream-2"),
						Repository: my_repo_upstream_2.ID(),
						Priority:   pulumi.Int(10),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var my_repo_upstream_1 = new Gcp.ArtifactRegistry.Repository("my-repo-upstream-1", new()
    {
        Location = "us-central1",
        RepositoryId = "my-repository-upstream-1",
        Description = "example docker repository (upstream source) 1",
        Format = "DOCKER",
    });

    var my_repo_upstream_2 = new Gcp.ArtifactRegistry.Repository("my-repo-upstream-2", new()
    {
        Location = "us-central1",
        RepositoryId = "my-repository-upstream-2",
        Description = "example docker repository (upstream source) 2",
        Format = "DOCKER",
    });

    var my_repo = new Gcp.ArtifactRegistry.Repository("my-repo", new()
    {
        Location = "us-central1",
        RepositoryId = "my-repository",
        Description = "example virtual docker repository",
        Format = "DOCKER",
        Mode = "VIRTUAL_REPOSITORY",
        VirtualRepositoryConfig = new Gcp.ArtifactRegistry.Inputs.RepositoryVirtualRepositoryConfigArgs
        {
            UpstreamPolicies = new[]
            {
                new Gcp.ArtifactRegistry.Inputs.RepositoryVirtualRepositoryConfigUpstreamPolicyArgs
                {
                    Id = "my-repository-upstream-1",
                    Repository = my_repo_upstream_1.Id,
                    Priority = 20,
                },
                new Gcp.ArtifactRegistry.Inputs.RepositoryVirtualRepositoryConfigUpstreamPolicyArgs
                {
                    Id = "my-repository-upstream-2",
                    Repository = my_repo_upstream_2.Id,
                    Priority = 10,
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.artifactregistry.Repository;
import com.pulumi.gcp.artifactregistry.RepositoryArgs;
import com.pulumi.gcp.artifactregistry.inputs.RepositoryVirtualRepositoryConfigArgs;
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 my_repo_upstream_1 = new Repository("my-repo-upstream-1", RepositoryArgs.builder()        
            .location("us-central1")
            .repositoryId("my-repository-upstream-1")
            .description("example docker repository (upstream source) 1")
            .format("DOCKER")
            .build());

        var my_repo_upstream_2 = new Repository("my-repo-upstream-2", RepositoryArgs.builder()        
            .location("us-central1")
            .repositoryId("my-repository-upstream-2")
            .description("example docker repository (upstream source) 2")
            .format("DOCKER")
            .build());

        var my_repo = new Repository("my-repo", RepositoryArgs.builder()        
            .location("us-central1")
            .repositoryId("my-repository")
            .description("example virtual docker repository")
            .format("DOCKER")
            .mode("VIRTUAL_REPOSITORY")
            .virtualRepositoryConfig(RepositoryVirtualRepositoryConfigArgs.builder()
                .upstreamPolicies(                
                    RepositoryVirtualRepositoryConfigUpstreamPolicyArgs.builder()
                        .id("my-repository-upstream-1")
                        .repository(my_repo_upstream_1.id())
                        .priority(20)
                        .build(),
                    RepositoryVirtualRepositoryConfigUpstreamPolicyArgs.builder()
                        .id("my-repository-upstream-2")
                        .repository(my_repo_upstream_2.id())
                        .priority(10)
                        .build())
                .build())
            .build());

    }
}

resources:
  my-repo-upstream-1:
    type: gcp:artifactregistry:Repository
    properties:
      location: us-central1
      repositoryId: my-repository-upstream-1
      description: example docker repository (upstream source) 1
      format: DOCKER
  my-repo-upstream-2:
    type: gcp:artifactregistry:Repository
    properties:
      location: us-central1
      repositoryId: my-repository-upstream-2
      description: example docker repository (upstream source) 2
      format: DOCKER
  my-repo:
    type: gcp:artifactregistry:Repository
    properties:
      location: us-central1
      repositoryId: my-repository
      description: example virtual docker repository
      format: DOCKER
      mode: VIRTUAL_REPOSITORY
      virtualRepositoryConfig:
        upstreamPolicies:
          - id: my-repository-upstream-1
            repository: ${["my-repo-upstream-1"].id}
            priority: 20
          - id: my-repository-upstream-2
            repository: ${["my-repo-upstream-2"].id}
            priority: 10

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

const my_repo = new gcp.artifactregistry.Repository("my-repo", {
    location: "us-central1",
    repositoryId: "my-repository",
    description: "example remote docker repository",
    format: "DOCKER",
    mode: "REMOTE_REPOSITORY",
    remoteRepositoryConfig: {
        description: "docker hub",
        dockerRepository: {
            publicRepository: "DOCKER_HUB",
        },
    },
});

import pulumi
import pulumi_gcp as gcp

my_repo = gcp.artifactregistry.Repository("my-repo",
    location="us-central1",
    repository_id="my-repository",
    description="example remote docker repository",
    format="DOCKER",
    mode="REMOTE_REPOSITORY",
    remote_repository_config=gcp.artifactregistry.RepositoryRemoteRepositoryConfigArgs(
        description="docker hub",
        docker_repository=gcp.artifactregistry.RepositoryRemoteRepositoryConfigDockerRepositoryArgs(
            public_repository="DOCKER_HUB",
        ),
    ))

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/artifactregistry"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := artifactregistry.NewRepository(ctx, "my-repo", &artifactregistry.RepositoryArgs{
			Location:     pulumi.String("us-central1"),
			RepositoryId: pulumi.String("my-repository"),
			Description:  pulumi.String("example remote docker repository"),
			Format:       pulumi.String("DOCKER"),
			Mode:         pulumi.String("REMOTE_REPOSITORY"),
			RemoteRepositoryConfig: &artifactregistry.RepositoryRemoteRepositoryConfigArgs{
				Description: pulumi.String("docker hub"),
				DockerRepository: &artifactregistry.RepositoryRemoteRepositoryConfigDockerRepositoryArgs{
					PublicRepository: pulumi.String("DOCKER_HUB"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var my_repo = new Gcp.ArtifactRegistry.Repository("my-repo", new()
    {
        Location = "us-central1",
        RepositoryId = "my-repository",
        Description = "example remote docker repository",
        Format = "DOCKER",
        Mode = "REMOTE_REPOSITORY",
        RemoteRepositoryConfig = new Gcp.ArtifactRegistry.Inputs.RepositoryRemoteRepositoryConfigArgs
        {
            Description = "docker hub",
            DockerRepository = new Gcp.ArtifactRegistry.Inputs.RepositoryRemoteRepositoryConfigDockerRepositoryArgs
            {
                PublicRepository = "DOCKER_HUB",
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.artifactregistry.Repository;
import com.pulumi.gcp.artifactregistry.RepositoryArgs;
import com.pulumi.gcp.artifactregistry.inputs.RepositoryRemoteRepositoryConfigArgs;
import com.pulumi.gcp.artifactregistry.inputs.RepositoryRemoteRepositoryConfigDockerRepositoryArgs;
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 my_repo = new Repository("my-repo", RepositoryArgs.builder()        
            .location("us-central1")
            .repositoryId("my-repository")
            .description("example remote docker repository")
            .format("DOCKER")
            .mode("REMOTE_REPOSITORY")
            .remoteRepositoryConfig(RepositoryRemoteRepositoryConfigArgs.builder()
                .description("docker hub")
                .dockerRepository(RepositoryRemoteRepositoryConfigDockerRepositoryArgs.builder()
                    .publicRepository("DOCKER_HUB")
                    .build())
                .build())
            .build());

    }
}

resources:
  my-repo:
    type: gcp:artifactregistry:Repository
    properties:
      location: us-central1
      repositoryId: my-repository
      description: example remote docker repository
      format: DOCKER
      mode: REMOTE_REPOSITORY
      remoteRepositoryConfig:
        description: docker hub
        dockerRepository:
          publicRepository: DOCKER_HUB

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

const my_repo = new gcp.artifactregistry.Repository("my-repo", {
    location: "us-central1",
    repositoryId: "debian-buster",
    description: "example remote apt repository",
    format: "APT",
    mode: "REMOTE_REPOSITORY",
    remoteRepositoryConfig: {
        description: "Debian buster remote repository",
        aptRepository: {
            publicRepository: {
                repositoryBase: "DEBIAN",
                repositoryPath: "debian/dists/buster",
            },
        },
    },
});

import pulumi
import pulumi_gcp as gcp

my_repo = gcp.artifactregistry.Repository("my-repo",
    location="us-central1",
    repository_id="debian-buster",
    description="example remote apt repository",
    format="APT",
    mode="REMOTE_REPOSITORY",
    remote_repository_config=gcp.artifactregistry.RepositoryRemoteRepositoryConfigArgs(
        description="Debian buster remote repository",
        apt_repository=gcp.artifactregistry.RepositoryRemoteRepositoryConfigAptRepositoryArgs(
            public_repository=gcp.artifactregistry.RepositoryRemoteRepositoryConfigAptRepositoryPublicRepositoryArgs(
                repository_base="DEBIAN",
                repository_path="debian/dists/buster",
            ),
        ),
    ))

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/artifactregistry"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := artifactregistry.NewRepository(ctx, "my-repo", &artifactregistry.RepositoryArgs{
			Location:     pulumi.String("us-central1"),
			RepositoryId: pulumi.String("debian-buster"),
			Description:  pulumi.String("example remote apt repository"),
			Format:       pulumi.String("APT"),
			Mode:         pulumi.String("REMOTE_REPOSITORY"),
			RemoteRepositoryConfig: &artifactregistry.RepositoryRemoteRepositoryConfigArgs{
				Description: pulumi.String("Debian buster remote repository"),
				AptRepository: &artifactregistry.RepositoryRemoteRepositoryConfigAptRepositoryArgs{
					PublicRepository: &artifactregistry.RepositoryRemoteRepositoryConfigAptRepositoryPublicRepositoryArgs{
						RepositoryBase: pulumi.String("DEBIAN"),
						RepositoryPath: pulumi.String("debian/dists/buster"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var my_repo = new Gcp.ArtifactRegistry.Repository("my-repo", new()
    {
        Location = "us-central1",
        RepositoryId = "debian-buster",
        Description = "example remote apt repository",
        Format = "APT",
        Mode = "REMOTE_REPOSITORY",
        RemoteRepositoryConfig = new Gcp.ArtifactRegistry.Inputs.RepositoryRemoteRepositoryConfigArgs
        {
            Description = "Debian buster remote repository",
            AptRepository = new Gcp.ArtifactRegistry.Inputs.RepositoryRemoteRepositoryConfigAptRepositoryArgs
            {
                PublicRepository = new Gcp.ArtifactRegistry.Inputs.RepositoryRemoteRepositoryConfigAptRepositoryPublicRepositoryArgs
                {
                    RepositoryBase = "DEBIAN",
                    RepositoryPath = "debian/dists/buster",
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.artifactregistry.Repository;
import com.pulumi.gcp.artifactregistry.RepositoryArgs;
import com.pulumi.gcp.artifactregistry.inputs.RepositoryRemoteRepositoryConfigArgs;
import com.pulumi.gcp.artifactregistry.inputs.RepositoryRemoteRepositoryConfigAptRepositoryArgs;
import com.pulumi.gcp.artifactregistry.inputs.RepositoryRemoteRepositoryConfigAptRepositoryPublicRepositoryArgs;
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 my_repo = new Repository("my-repo", RepositoryArgs.builder()        
            .location("us-central1")
            .repositoryId("debian-buster")
            .description("example remote apt repository")
            .format("APT")
            .mode("REMOTE_REPOSITORY")
            .remoteRepositoryConfig(RepositoryRemoteRepositoryConfigArgs.builder()
                .description("Debian buster remote repository")
                .aptRepository(RepositoryRemoteRepositoryConfigAptRepositoryArgs.builder()
                    .publicRepository(RepositoryRemoteRepositoryConfigAptRepositoryPublicRepositoryArgs.builder()
                        .repositoryBase("DEBIAN")
                        .repositoryPath("debian/dists/buster")
                        .build())
                    .build())
                .build())
            .build());

    }
}

resources:
  my-repo:
    type: gcp:artifactregistry:Repository
    properties:
      location: us-central1
      repositoryId: debian-buster
      description: example remote apt repository
      format: APT
      mode: REMOTE_REPOSITORY
      remoteRepositoryConfig:
        description: Debian buster remote repository
        aptRepository:
          publicRepository:
            repositoryBase: DEBIAN
            repositoryPath: debian/dists/buster

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

const my_repo = new gcp.artifactregistry.Repository("my-repo", {
    location: "us-central1",
    repositoryId: "centos-8",
    description: "example remote yum repository",
    format: "YUM",
    mode: "REMOTE_REPOSITORY",
    remoteRepositoryConfig: {
        description: "Centos 8 remote repository",
        yumRepository: {
            publicRepository: {
                repositoryBase: "CENTOS",
                repositoryPath: "centos/8-stream/BaseOS/x86_64/os",
            },
        },
    },
});

import pulumi
import pulumi_gcp as gcp

my_repo = gcp.artifactregistry.Repository("my-repo",
    location="us-central1",
    repository_id="centos-8",
    description="example remote yum repository",
    format="YUM",
    mode="REMOTE_REPOSITORY",
    remote_repository_config=gcp.artifactregistry.RepositoryRemoteRepositoryConfigArgs(
        description="Centos 8 remote repository",
        yum_repository=gcp.artifactregistry.RepositoryRemoteRepositoryConfigYumRepositoryArgs(
            public_repository=gcp.artifactregistry.RepositoryRemoteRepositoryConfigYumRepositoryPublicRepositoryArgs(
                repository_base="CENTOS",
                repository_path="centos/8-stream/BaseOS/x86_64/os",
            ),
        ),
    ))

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/artifactregistry"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := artifactregistry.NewRepository(ctx, "my-repo", &artifactregistry.RepositoryArgs{
			Location:     pulumi.String("us-central1"),
			RepositoryId: pulumi.String("centos-8"),
			Description:  pulumi.String("example remote yum repository"),
			Format:       pulumi.String("YUM"),
			Mode:         pulumi.String("REMOTE_REPOSITORY"),
			RemoteRepositoryConfig: &artifactregistry.RepositoryRemoteRepositoryConfigArgs{
				Description: pulumi.String("Centos 8 remote repository"),
				YumRepository: &artifactregistry.RepositoryRemoteRepositoryConfigYumRepositoryArgs{
					PublicRepository: &artifactregistry.RepositoryRemoteRepositoryConfigYumRepositoryPublicRepositoryArgs{
						RepositoryBase: pulumi.String("CENTOS"),
						RepositoryPath: pulumi.String("centos/8-stream/BaseOS/x86_64/os"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var my_repo = new Gcp.ArtifactRegistry.Repository("my-repo", new()
    {
        Location = "us-central1",
        RepositoryId = "centos-8",
        Description = "example remote yum repository",
        Format = "YUM",
        Mode = "REMOTE_REPOSITORY",
        RemoteRepositoryConfig = new Gcp.ArtifactRegistry.Inputs.RepositoryRemoteRepositoryConfigArgs
        {
            Description = "Centos 8 remote repository",
            YumRepository = new Gcp.ArtifactRegistry.Inputs.RepositoryRemoteRepositoryConfigYumRepositoryArgs
            {
                PublicRepository = new Gcp.ArtifactRegistry.Inputs.RepositoryRemoteRepositoryConfigYumRepositoryPublicRepositoryArgs
                {
                    RepositoryBase = "CENTOS",
                    RepositoryPath = "centos/8-stream/BaseOS/x86_64/os",
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.artifactregistry.Repository;
import com.pulumi.gcp.artifactregistry.RepositoryArgs;
import com.pulumi.gcp.artifactregistry.inputs.RepositoryRemoteRepositoryConfigArgs;
import com.pulumi.gcp.artifactregistry.inputs.RepositoryRemoteRepositoryConfigYumRepositoryArgs;
import com.pulumi.gcp.artifactregistry.inputs.RepositoryRemoteRepositoryConfigYumRepositoryPublicRepositoryArgs;
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 my_repo = new Repository("my-repo", RepositoryArgs.builder()        
            .location("us-central1")
            .repositoryId("centos-8")
            .description("example remote yum repository")
            .format("YUM")
            .mode("REMOTE_REPOSITORY")
            .remoteRepositoryConfig(RepositoryRemoteRepositoryConfigArgs.builder()
                .description("Centos 8 remote repository")
                .yumRepository(RepositoryRemoteRepositoryConfigYumRepositoryArgs.builder()
                    .publicRepository(RepositoryRemoteRepositoryConfigYumRepositoryPublicRepositoryArgs.builder()
                        .repositoryBase("CENTOS")
                        .repositoryPath("centos/8-stream/BaseOS/x86_64/os")
                        .build())
                    .build())
                .build())
            .build());

    }
}

resources:
  my-repo:
    type: gcp:artifactregistry:Repository
    properties:
      location: us-central1
      repositoryId: centos-8
      description: example remote yum repository
      format: YUM
      mode: REMOTE_REPOSITORY
      remoteRepositoryConfig:
        description: Centos 8 remote repository
        yumRepository:
          publicRepository:
            repositoryBase: CENTOS
            repositoryPath: centos/8-stream/BaseOS/x86_64/os

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

const my_repo = new gcp.artifactregistry.Repository("my-repo", {
    location: "us-central1",
    repositoryId: "my-repository",
    description: "example docker repository with cleanup policies",
    format: "DOCKER",
    cleanupPolicyDryRun: false,
    cleanupPolicies: [
        {
            id: "delete-prerelease",
            action: "DELETE",
            condition: {
                tagState: "TAGGED",
                tagPrefixes: [
                    "alpha",
                    "v0",
                ],
                olderThan: "2592000s",
            },
        },
        {
            id: "keep-tagged-release",
            action: "KEEP",
            condition: {
                tagState: "TAGGED",
                tagPrefixes: ["release"],
                packageNamePrefixes: [
                    "webapp",
                    "mobile",
                ],
            },
        },
        {
            id: "keep-minimum-versions",
            action: "KEEP",
            mostRecentVersions: {
                packageNamePrefixes: [
                    "webapp",
                    "mobile",
                    "sandbox",
                ],
                keepCount: 5,
            },
        },
    ],
});

import pulumi
import pulumi_gcp as gcp

my_repo = gcp.artifactregistry.Repository("my-repo",
    location="us-central1",
    repository_id="my-repository",
    description="example docker repository with cleanup policies",
    format="DOCKER",
    cleanup_policy_dry_run=False,
    cleanup_policies=[
        gcp.artifactregistry.RepositoryCleanupPolicyArgs(
            id="delete-prerelease",
            action="DELETE",
            condition=gcp.artifactregistry.RepositoryCleanupPolicyConditionArgs(
                tag_state="TAGGED",
                tag_prefixes=[
                    "alpha",
                    "v0",
                ],
                older_than="2592000s",
            ),
        ),
        gcp.artifactregistry.RepositoryCleanupPolicyArgs(
            id="keep-tagged-release",
            action="KEEP",
            condition=gcp.artifactregistry.RepositoryCleanupPolicyConditionArgs(
                tag_state="TAGGED",
                tag_prefixes=["release"],
                package_name_prefixes=[
                    "webapp",
                    "mobile",
                ],
            ),
        ),
        gcp.artifactregistry.RepositoryCleanupPolicyArgs(
            id="keep-minimum-versions",
            action="KEEP",
            most_recent_versions=gcp.artifactregistry.RepositoryCleanupPolicyMostRecentVersionsArgs(
                package_name_prefixes=[
                    "webapp",
                    "mobile",
                    "sandbox",
                ],
                keep_count=5,
            ),
        ),
    ])

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/artifactregistry"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := artifactregistry.NewRepository(ctx, "my-repo", &artifactregistry.RepositoryArgs{
			Location:            pulumi.String("us-central1"),
			RepositoryId:        pulumi.String("my-repository"),
			Description:         pulumi.String("example docker repository with cleanup policies"),
			Format:              pulumi.String("DOCKER"),
			CleanupPolicyDryRun: pulumi.Bool(false),
			CleanupPolicies: artifactregistry.RepositoryCleanupPolicyArray{
				&artifactregistry.RepositoryCleanupPolicyArgs{
					Id:     pulumi.String("delete-prerelease"),
					Action: pulumi.String("DELETE"),
					Condition: &artifactregistry.RepositoryCleanupPolicyConditionArgs{
						TagState: pulumi.String("TAGGED"),
						TagPrefixes: pulumi.StringArray{
							pulumi.String("alpha"),
							pulumi.String("v0"),
						},
						OlderThan: pulumi.String("2592000s"),
					},
				},
				&artifactregistry.RepositoryCleanupPolicyArgs{
					Id:     pulumi.String("keep-tagged-release"),
					Action: pulumi.String("KEEP"),
					Condition: &artifactregistry.RepositoryCleanupPolicyConditionArgs{
						TagState: pulumi.String("TAGGED"),
						TagPrefixes: pulumi.StringArray{
							pulumi.String("release"),
						},
						PackageNamePrefixes: pulumi.StringArray{
							pulumi.String("webapp"),
							pulumi.String("mobile"),
						},
					},
				},
				&artifactregistry.RepositoryCleanupPolicyArgs{
					Id:     pulumi.String("keep-minimum-versions"),
					Action: pulumi.String("KEEP"),
					MostRecentVersions: &artifactregistry.RepositoryCleanupPolicyMostRecentVersionsArgs{
						PackageNamePrefixes: pulumi.StringArray{
							pulumi.String("webapp"),
							pulumi.String("mobile"),
							pulumi.String("sandbox"),
						},
						KeepCount: pulumi.Int(5),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var my_repo = new Gcp.ArtifactRegistry.Repository("my-repo", new()
    {
        Location = "us-central1",
        RepositoryId = "my-repository",
        Description = "example docker repository with cleanup policies",
        Format = "DOCKER",
        CleanupPolicyDryRun = false,
        CleanupPolicies = new[]
        {
            new Gcp.ArtifactRegistry.Inputs.RepositoryCleanupPolicyArgs
            {
                Id = "delete-prerelease",
                Action = "DELETE",
                Condition = new Gcp.ArtifactRegistry.Inputs.RepositoryCleanupPolicyConditionArgs
                {
                    TagState = "TAGGED",
                    TagPrefixes = new[]
                    {
                        "alpha",
                        "v0",
                    },
                    OlderThan = "2592000s",
                },
            },
            new Gcp.ArtifactRegistry.Inputs.RepositoryCleanupPolicyArgs
            {
                Id = "keep-tagged-release",
                Action = "KEEP",
                Condition = new Gcp.ArtifactRegistry.Inputs.RepositoryCleanupPolicyConditionArgs
                {
                    TagState = "TAGGED",
                    TagPrefixes = new[]
                    {
                        "release",
                    },
                    PackageNamePrefixes = new[]
                    {
                        "webapp",
                        "mobile",
                    },
                },
            },
            new Gcp.ArtifactRegistry.Inputs.RepositoryCleanupPolicyArgs
            {
                Id = "keep-minimum-versions",
                Action = "KEEP",
                MostRecentVersions = new Gcp.ArtifactRegistry.Inputs.RepositoryCleanupPolicyMostRecentVersionsArgs
                {
                    PackageNamePrefixes = new[]
                    {
                        "webapp",
                        "mobile",
                        "sandbox",
                    },
                    KeepCount = 5,
                },
            },
        },
    });

});