Using gcp utils with project

Question

Pulumi · Accepted Answer

When you're working with Google Cloud Platform (GCP) and Pulumi, you'll often start by setting up a GCP Project. A project in GCP is a container for all your work on any given initiative. Everything you do in GCP happens within a project, from creating virtual machines, to adding APIs, to setting usage limits.

Pulumi has a resource called `Project` in the `gcp` package that you can use to create, configure, and manage GCP projects.

Here's how you can use Pulumi to create a GCP project. I'll explain each part of the program as we go through it.

1. First, we'll import the `@pulumi/gcp` package. This contains the necessary classes and functions to work with GCP resources.
2. Next, we'll create a new GCP project using the `Project` resource.
3. We can set project-level metadata with the `ProjectMetadata` resource if required.
4. We'll also ensure that any necessary APIs are enabled for our project using the `Service` resource.

Each resource has properties that you can set to configure your project. For example, `projectId` specifies the unique ID of your project, and `name` specifies the name.

Below is a TypeScript program that uses the `@pulumi/gcp` package to create a new GCP project and enables a couple of APIs:

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

// Create a new GCP project
const project = new gcp.organizations.Project("my-project", {
    name: "my-project-name",
    projectId: "my-unique-project-id",
});

// Set project-wide metadata, this is optional
const projectMetadata = new gcp.compute.ProjectMetadata("my-metadata", {
    metadata: {
        key: "value",
    },
    project: project.projectId,
}, { dependsOn: [project] });

// Enable the Compute Engine API for the project
const computeApi = new gcp.projects.Service("compute-api", {
    project: project.projectId,
    service: "compute.googleapis.com",
}, { dependsOn: [project] });

// Enable the Cloud Storage API for the project
const storageApi = new gcp.projects.Service("storage-api", {
    project: project.projectId,
    service: "storage.googleapis.com",
}, { dependsOn: [project] });

// Export the project ID
export const projectId = project.projectId;
```

In the above program:

- We create a `Project` resource named `my-project`. You need to provide a `projectId` which is globally unique and a `name` which is a friendly name for the project. Replace `"my-unique-project-id"` with your desired project ID and `"my-project-name"` with your project's display name.
- We then define optional project-wide metadata using the `ProjectMetadata` resource. In this example, we're setting dummy key-value pairs. This part is not mandatory, and you can omit it if you don't have any project-wide metadata to add.
- Next, we enable necessary Google Cloud APIs for the project. The `Service` resource is used to turn on APIs; here, we're enabling Google Compute Engine and Google Cloud Storage, which are common for a wide variety of tasks in GCP.
- Lastly, we export the project ID using `export const projectId = project.projectId;`. This makes it possible to access the project ID outside of Pulumi, for instance, if other resources need to be associated with this project later.

This program provides a skeleton for setting up a project in GCP with Pulumi. You can extend it by adding more resources or configuring more project settings depending on your needs.