gcp.apigee.EnvGroupAttachment

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

return await Deployment.RunAsync(() => 
{
    var project = new Gcp.Organizations.Project("project", new()
    {
        ProjectId = "my-project",
        OrgId = "",
        BillingAccount = "",
    });

    var apigee = new Gcp.Projects.Service("apigee", new()
    {
        Project = project.ProjectId,
        ServiceName = "apigee.googleapis.com",
    });

    var compute = new Gcp.Projects.Service("compute", new()
    {
        Project = project.ProjectId,
        ServiceName = "compute.googleapis.com",
    });

    var servicenetworking = new Gcp.Projects.Service("servicenetworking", new()
    {
        Project = project.ProjectId,
        ServiceName = "servicenetworking.googleapis.com",
    });

    var apigeeNetwork = new Gcp.Compute.Network("apigeeNetwork", new()
    {
        Project = project.ProjectId,
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            compute,
        },
    });

    var apigeeRange = new Gcp.Compute.GlobalAddress("apigeeRange", new()
    {
        Purpose = "VPC_PEERING",
        AddressType = "INTERNAL",
        PrefixLength = 16,
        Network = apigeeNetwork.Id,
        Project = project.ProjectId,
    });

    var apigeeVpcConnection = new Gcp.ServiceNetworking.Connection("apigeeVpcConnection", new()
    {
        Network = apigeeNetwork.Id,
        Service = "servicenetworking.googleapis.com",
        ReservedPeeringRanges = new[]
        {
            apigeeRange.Name,
        },
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            servicenetworking,
        },
    });

    var apigeeOrg = new Gcp.Apigee.Organization("apigeeOrg", new()
    {
        AnalyticsRegion = "us-central1",
        ProjectId = project.ProjectId,
        AuthorizedNetwork = apigeeNetwork.Id,
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            apigeeVpcConnection,
            apigee,
        },
    });

    var apigeeEnvgroup = new Gcp.Apigee.EnvGroup("apigeeEnvgroup", new()
    {
        OrgId = apigeeOrg.Id,
        Hostnames = new[]
        {
            "abc.foo.com",
        },
    });

    var apigeeEnv = new Gcp.Apigee.Environment("apigeeEnv", new()
    {
        OrgId = apigeeOrg.Id,
        Description = "Apigee Environment",
        DisplayName = "my-environment",
    });

    var envGroupAttachment = new Gcp.Apigee.EnvGroupAttachment("envGroupAttachment", new()
    {
        EnvgroupId = apigeeEnvgroup.Id,
        Environment = apigeeEnv.Name,
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/apigee"
	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/projects"
	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/servicenetworking"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		project, err := organizations.NewProject(ctx, "project", &organizations.ProjectArgs{
			ProjectId:      pulumi.String("my-project"),
			OrgId:          pulumi.String(""),
			BillingAccount: pulumi.String(""),
		})
		if err != nil {
			return err
		}
		apigee, err := projects.NewService(ctx, "apigee", &projects.ServiceArgs{
			Project: project.ProjectId,
			Service: pulumi.String("apigee.googleapis.com"),
		})
		if err != nil {
			return err
		}
		compute, err := projects.NewService(ctx, "compute", &projects.ServiceArgs{
			Project: project.ProjectId,
			Service: pulumi.String("compute.googleapis.com"),
		})
		if err != nil {
			return err
		}
		servicenetworking, err := projects.NewService(ctx, "servicenetworking", &projects.ServiceArgs{
			Project: project.ProjectId,
			Service: pulumi.String("servicenetworking.googleapis.com"),
		})
		if err != nil {
			return err
		}
		apigeeNetwork, err := compute.NewNetwork(ctx, "apigeeNetwork", &compute.NetworkArgs{
			Project: project.ProjectId,
		}, pulumi.DependsOn([]pulumi.Resource{
			compute,
		}))
		if err != nil {
			return err
		}
		apigeeRange, err := compute.NewGlobalAddress(ctx, "apigeeRange", &compute.GlobalAddressArgs{
			Purpose:      pulumi.String("VPC_PEERING"),
			AddressType:  pulumi.String("INTERNAL"),
			PrefixLength: pulumi.Int(16),
			Network:      apigeeNetwork.ID(),
			Project:      project.ProjectId,
		})
		if err != nil {
			return err
		}
		apigeeVpcConnection, err := servicenetworking.NewConnection(ctx, "apigeeVpcConnection", &servicenetworking.ConnectionArgs{
			Network: apigeeNetwork.ID(),
			Service: pulumi.String("servicenetworking.googleapis.com"),
			ReservedPeeringRanges: pulumi.StringArray{
				apigeeRange.Name,
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			servicenetworking,
		}))
		if err != nil {
			return err
		}
		apigeeOrg, err := apigee.NewOrganization(ctx, "apigeeOrg", &apigee.OrganizationArgs{
			AnalyticsRegion:   pulumi.String("us-central1"),
			ProjectId:         project.ProjectId,
			AuthorizedNetwork: apigeeNetwork.ID(),
		}, pulumi.DependsOn([]pulumi.Resource{
			apigeeVpcConnection,
			apigee,
		}))
		if err != nil {
			return err
		}
		apigeeEnvgroup, err := apigee.NewEnvGroup(ctx, "apigeeEnvgroup", &apigee.EnvGroupArgs{
			OrgId: apigeeOrg.ID(),
			Hostnames: pulumi.StringArray{
				pulumi.String("abc.foo.com"),
			},
		})
		if err != nil {
			return err
		}
		apigeeEnv, err := apigee.NewEnvironment(ctx, "apigeeEnv", &apigee.EnvironmentArgs{
			OrgId:       apigeeOrg.ID(),
			Description: pulumi.String("Apigee Environment"),
			DisplayName: pulumi.String("my-environment"),
		})
		if err != nil {
			return err
		}
		_, err = apigee.NewEnvGroupAttachment(ctx, "envGroupAttachment", &apigee.EnvGroupAttachmentArgs{
			EnvgroupId:  apigeeEnvgroup.ID(),
			Environment: apigeeEnv.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.organizations.Project;
import com.pulumi.gcp.organizations.ProjectArgs;
import com.pulumi.gcp.projects.Service;
import com.pulumi.gcp.projects.ServiceArgs;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.compute.GlobalAddress;
import com.pulumi.gcp.compute.GlobalAddressArgs;
import com.pulumi.gcp.servicenetworking.Connection;
import com.pulumi.gcp.servicenetworking.ConnectionArgs;
import com.pulumi.gcp.apigee.Organization;
import com.pulumi.gcp.apigee.OrganizationArgs;
import com.pulumi.gcp.apigee.EnvGroup;
import com.pulumi.gcp.apigee.EnvGroupArgs;
import com.pulumi.gcp.apigee.Environment;
import com.pulumi.gcp.apigee.EnvironmentArgs;
import com.pulumi.gcp.apigee.EnvGroupAttachment;
import com.pulumi.gcp.apigee.EnvGroupAttachmentArgs;
import com.pulumi.resources.CustomResourceOptions;
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 project = new Project("project", ProjectArgs.builder()        
            .projectId("my-project")
            .orgId("")
            .billingAccount("")
            .build());

        var apigee = new Service("apigee", ServiceArgs.builder()        
            .project(project.projectId())
            .service("apigee.googleapis.com")
            .build());

        var compute = new Service("compute", ServiceArgs.builder()        
            .project(project.projectId())
            .service("compute.googleapis.com")
            .build());

        var servicenetworking = new Service("servicenetworking", ServiceArgs.builder()        
            .project(project.projectId())
            .service("servicenetworking.googleapis.com")
            .build());

        var apigeeNetwork = new Network("apigeeNetwork", NetworkArgs.builder()        
            .project(project.projectId())
            .build(), CustomResourceOptions.builder()
                .dependsOn(compute)
                .build());

        var apigeeRange = new GlobalAddress("apigeeRange", GlobalAddressArgs.builder()        
            .purpose("VPC_PEERING")
            .addressType("INTERNAL")
            .prefixLength(16)
            .network(apigeeNetwork.id())
            .project(project.projectId())
            .build());

        var apigeeVpcConnection = new Connection("apigeeVpcConnection", ConnectionArgs.builder()        
            .network(apigeeNetwork.id())
            .service("servicenetworking.googleapis.com")
            .reservedPeeringRanges(apigeeRange.name())
            .build(), CustomResourceOptions.builder()
                .dependsOn(servicenetworking)
                .build());

        var apigeeOrg = new Organization("apigeeOrg", OrganizationArgs.builder()        
            .analyticsRegion("us-central1")
            .projectId(project.projectId())
            .authorizedNetwork(apigeeNetwork.id())
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    apigeeVpcConnection,
                    apigee)
                .build());

        var apigeeEnvgroup = new EnvGroup("apigeeEnvgroup", EnvGroupArgs.builder()        
            .orgId(apigeeOrg.id())
            .hostnames("abc.foo.com")
            .build());

        var apigeeEnv = new Environment("apigeeEnv", EnvironmentArgs.builder()        
            .orgId(apigeeOrg.id())
            .description("Apigee Environment")
            .displayName("my-environment")
            .build());

        var envGroupAttachment = new EnvGroupAttachment("envGroupAttachment", EnvGroupAttachmentArgs.builder()        
            .envgroupId(apigeeEnvgroup.id())
            .environment(apigeeEnv.name())
            .build());

    }
}

import pulumi
import pulumi_gcp as gcp

project = gcp.organizations.Project("project",
    project_id="my-project",
    org_id="",
    billing_account="")
apigee = gcp.projects.Service("apigee",
    project=project.project_id,
    service="apigee.googleapis.com")
compute = gcp.projects.Service("compute",
    project=project.project_id,
    service="compute.googleapis.com")
servicenetworking = gcp.projects.Service("servicenetworking",
    project=project.project_id,
    service="servicenetworking.googleapis.com")
apigee_network = gcp.compute.Network("apigeeNetwork", project=project.project_id,
opts=pulumi.ResourceOptions(depends_on=[compute]))
apigee_range = gcp.compute.GlobalAddress("apigeeRange",
    purpose="VPC_PEERING",
    address_type="INTERNAL",
    prefix_length=16,
    network=apigee_network.id,
    project=project.project_id)
apigee_vpc_connection = gcp.servicenetworking.Connection("apigeeVpcConnection",
    network=apigee_network.id,
    service="servicenetworking.googleapis.com",
    reserved_peering_ranges=[apigee_range.name],
    opts=pulumi.ResourceOptions(depends_on=[servicenetworking]))
apigee_org = gcp.apigee.Organization("apigeeOrg",
    analytics_region="us-central1",
    project_id=project.project_id,
    authorized_network=apigee_network.id,
    opts=pulumi.ResourceOptions(depends_on=[
            apigee_vpc_connection,
            apigee,
        ]))
apigee_envgroup = gcp.apigee.EnvGroup("apigeeEnvgroup",
    org_id=apigee_org.id,
    hostnames=["abc.foo.com"])
apigee_env = gcp.apigee.Environment("apigeeEnv",
    org_id=apigee_org.id,
    description="Apigee Environment",
    display_name="my-environment")
env_group_attachment = gcp.apigee.EnvGroupAttachment("envGroupAttachment",
    envgroup_id=apigee_envgroup.id,
    environment=apigee_env.name)

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

const project = new gcp.organizations.Project("project", {
    projectId: "my-project",
    orgId: "",
    billingAccount: "",
});
const apigee = new gcp.projects.Service("apigee", {
    project: project.projectId,
    service: "apigee.googleapis.com",
});
const compute = new gcp.projects.Service("compute", {
    project: project.projectId,
    service: "compute.googleapis.com",
});
const servicenetworking = new gcp.projects.Service("servicenetworking", {
    project: project.projectId,
    service: "servicenetworking.googleapis.com",
});
const apigeeNetwork = new gcp.compute.Network("apigeeNetwork", {project: project.projectId}, {
    dependsOn: [compute],
});
const apigeeRange = new gcp.compute.GlobalAddress("apigeeRange", {
    purpose: "VPC_PEERING",
    addressType: "INTERNAL",
    prefixLength: 16,
    network: apigeeNetwork.id,
    project: project.projectId,
});
const apigeeVpcConnection = new gcp.servicenetworking.Connection("apigeeVpcConnection", {
    network: apigeeNetwork.id,
    service: "servicenetworking.googleapis.com",
    reservedPeeringRanges: [apigeeRange.name],
}, {
    dependsOn: [servicenetworking],
});
const apigeeOrg = new gcp.apigee.Organization("apigeeOrg", {
    analyticsRegion: "us-central1",
    projectId: project.projectId,
    authorizedNetwork: apigeeNetwork.id,
}, {
    dependsOn: [
        apigeeVpcConnection,
        apigee,
    ],
});
const apigeeEnvgroup = new gcp.apigee.EnvGroup("apigeeEnvgroup", {
    orgId: apigeeOrg.id,
    hostnames: ["abc.foo.com"],
});
const apigeeEnv = new gcp.apigee.Environment("apigeeEnv", {
    orgId: apigeeOrg.id,
    description: "Apigee Environment",
    displayName: "my-environment",
});
const envGroupAttachment = new gcp.apigee.EnvGroupAttachment("envGroupAttachment", {
    envgroupId: apigeeEnvgroup.id,
    environment: apigeeEnv.name,
});

resources:
  project:
    type: gcp:organizations:Project
    properties:
      projectId: my-project
      orgId:
      billingAccount:
  apigee:
    type: gcp:projects:Service
    properties:
      project: ${project.projectId}
      service: apigee.googleapis.com
  compute:
    type: gcp:projects:Service
    properties:
      project: ${project.projectId}
      service: compute.googleapis.com
  servicenetworking:
    type: gcp:projects:Service
    properties:
      project: ${project.projectId}
      service: servicenetworking.googleapis.com
  apigeeNetwork:
    type: gcp:compute:Network
    properties:
      project: ${project.projectId}
    options:
      dependson:
        - ${compute}
  apigeeRange:
    type: gcp:compute:GlobalAddress
    properties:
      purpose: VPC_PEERING
      addressType: INTERNAL
      prefixLength: 16
      network: ${apigeeNetwork.id}
      project: ${project.projectId}
  apigeeVpcConnection:
    type: gcp:servicenetworking:Connection
    properties:
      network: ${apigeeNetwork.id}
      service: servicenetworking.googleapis.com
      reservedPeeringRanges:
        - ${apigeeRange.name}
    options:
      dependson:
        - ${servicenetworking}
  apigeeOrg:
    type: gcp:apigee:Organization
    properties:
      analyticsRegion: us-central1
      projectId: ${project.projectId}
      authorizedNetwork: ${apigeeNetwork.id}
    options:
      dependson:
        - ${apigeeVpcConnection}
        - ${apigee}
  apigeeEnvgroup:
    type: gcp:apigee:EnvGroup
    properties:
      orgId: ${apigeeOrg.id}
      hostnames:
        - abc.foo.com
  apigeeEnv:
    type: gcp:apigee:Environment
    properties:
      orgId: ${apigeeOrg.id}
      description: Apigee Environment
      displayName: my-environment
  envGroupAttachment:
    type: gcp:apigee:EnvGroupAttachment
    properties:
      envgroupId: ${apigeeEnvgroup.id}
      environment: ${apigeeEnv.name}