DomainMapping

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const _default = new gcp.cloudrun.Service("default", {
    name: "cloudrun-srv",
    location: "us-central1",
    metadata: {
        namespace: "my-project-name",
    },
    template: {
        spec: {
            containers: [{
                image: "us-docker.pkg.dev/cloudrun/container/hello",
            }],
        },
    },
});
const defaultDomainMapping = new gcp.cloudrun.DomainMapping("default", {
    location: "us-central1",
    name: "verified-domain.com",
    metadata: {
        namespace: "my-project-name",
    },
    spec: {
        routeName: _default.name,
    },
});

import pulumi
import pulumi_gcp as gcp
default = gcp.cloudrun.Service("default",
    name="cloudrun-srv",
    location="us-central1",
    metadata={
        "namespace": "my-project-name",
    },
    template={
        "spec": {
            "containers": [{
                "image": "us-docker.pkg.dev/cloudrun/container/hello",
            }],
        },
    })
default_domain_mapping = gcp.cloudrun.DomainMapping("default",
    location="us-central1",
    name="verified-domain.com",
    metadata={
        "namespace": "my-project-name",
    },
    spec={
        "route_name": default.name,
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var @default = new Gcp.CloudRun.Service("default", new()
    {
        Name = "cloudrun-srv",
        Location = "us-central1",
        Metadata = new Gcp.CloudRun.Inputs.ServiceMetadataArgs
        {
            Namespace = "my-project-name",
        },
        Template = new Gcp.CloudRun.Inputs.ServiceTemplateArgs
        {
            Spec = new Gcp.CloudRun.Inputs.ServiceTemplateSpecArgs
            {
                Containers = new[]
                {
                    new Gcp.CloudRun.Inputs.ServiceTemplateSpecContainerArgs
                    {
                        Image = "us-docker.pkg.dev/cloudrun/container/hello",
                    },
                },
            },
        },
    });
    var defaultDomainMapping = new Gcp.CloudRun.DomainMapping("default", new()
    {
        Location = "us-central1",
        Name = "verified-domain.com",
        Metadata = new Gcp.CloudRun.Inputs.DomainMappingMetadataArgs
        {
            Namespace = "my-project-name",
        },
        Spec = new Gcp.CloudRun.Inputs.DomainMappingSpecArgs
        {
            RouteName = @default.Name,
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudrun"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudrun.NewService(ctx, "default", &cloudrun.ServiceArgs{
			Name:     pulumi.String("cloudrun-srv"),
			Location: pulumi.String("us-central1"),
			Metadata: &cloudrun.ServiceMetadataArgs{
				Namespace: pulumi.String("my-project-name"),
			},
			Template: &cloudrun.ServiceTemplateArgs{
				Spec: &cloudrun.ServiceTemplateSpecArgs{
					Containers: cloudrun.ServiceTemplateSpecContainerArray{
						&cloudrun.ServiceTemplateSpecContainerArgs{
							Image: pulumi.String("us-docker.pkg.dev/cloudrun/container/hello"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = cloudrun.NewDomainMapping(ctx, "default", &cloudrun.DomainMappingArgs{
			Location: pulumi.String("us-central1"),
			Name:     pulumi.String("verified-domain.com"),
			Metadata: &cloudrun.DomainMappingMetadataArgs{
				Namespace: pulumi.String("my-project-name"),
			},
			Spec: &cloudrun.DomainMappingSpecArgs{
				RouteName: _default.Name,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.cloudrun.Service;
import com.pulumi.gcp.cloudrun.ServiceArgs;
import com.pulumi.gcp.cloudrun.inputs.ServiceMetadataArgs;
import com.pulumi.gcp.cloudrun.inputs.ServiceTemplateArgs;
import com.pulumi.gcp.cloudrun.inputs.ServiceTemplateSpecArgs;
import com.pulumi.gcp.cloudrun.DomainMapping;
import com.pulumi.gcp.cloudrun.DomainMappingArgs;
import com.pulumi.gcp.cloudrun.inputs.DomainMappingMetadataArgs;
import com.pulumi.gcp.cloudrun.inputs.DomainMappingSpecArgs;
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 default_ = new Service("default", ServiceArgs.builder()
            .name("cloudrun-srv")
            .location("us-central1")
            .metadata(ServiceMetadataArgs.builder()
                .namespace("my-project-name")
                .build())
            .template(ServiceTemplateArgs.builder()
                .spec(ServiceTemplateSpecArgs.builder()
                    .containers(ServiceTemplateSpecContainerArgs.builder()
                        .image("us-docker.pkg.dev/cloudrun/container/hello")
                        .build())
                    .build())
                .build())
            .build());
        var defaultDomainMapping = new DomainMapping("defaultDomainMapping", DomainMappingArgs.builder()
            .location("us-central1")
            .name("verified-domain.com")
            .metadata(DomainMappingMetadataArgs.builder()
                .namespace("my-project-name")
                .build())
            .spec(DomainMappingSpecArgs.builder()
                .routeName(default_.name())
                .build())
            .build());
    }
}

resources:
  default:
    type: gcp:cloudrun:Service
    properties:
      name: cloudrun-srv
      location: us-central1
      metadata:
        namespace: my-project-name
      template:
        spec:
          containers:
            - image: us-docker.pkg.dev/cloudrun/container/hello
  defaultDomainMapping:
    type: gcp:cloudrun:DomainMapping
    name: default
    properties:
      location: us-central1
      name: verified-domain.com
      metadata:
        namespace: my-project-name
      spec:
        routeName: ${default.name}

$ pulumi import gcp:cloudrun/domainMapping:DomainMapping default locations/{{location}}/namespaces/{{project}}/domainmappings/{{name}}

$ pulumi import gcp:cloudrun/domainMapping:DomainMapping default {{location}}/{{project}}/{{name}}

$ pulumi import gcp:cloudrun/domainMapping:DomainMapping default {{location}}/{{name}}